Attachment 283101 Details for Bug 417961 – patch 1 -- update RHEL5's cifs code to 1.50c

[patch] patch 1 -- update RHEL5's cifs code to 1.50c

0001-BZ-417961-CIFS-Stock-1.50c-import.patch (text/plain), 733.94 KB, created by Jeff Layton on 2007-12-10 20:18:03 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Jeff Layton

Created: 2007-12-10 20:18:03 UTC

Size: 733.94 KB

patch

obsolete

>From 23a2b16745f127e1b0ae036a47d356a2a18f9876 Mon Sep 17 00:00:00 2001
>From: Jeff Layton <jlayton@redhat.com>
>Date: Mon, 10 Dec 2007 07:42:02 -0500
>Subject: [RHEL5.2 PATCH 01/16] BZ#417961: [CIFS] Stock 1.50c import
>
>Update CIFS code to Steve French's upstream 1.50c tarball. This
>patch represents the replacement of the current RHEL5 cifs code
>with the contents of the backported tarball available here:
>
>http://pserver.samba.org/samba/ftp/cifs-cvs/cifs-1.50c.tar.gz
>---
> fs/cifs/CHANGES        |   48 ++-
> fs/cifs/README         |  100 ++-
> fs/cifs/TODO           |   72 +-
> fs/cifs/asn1.c         |   70 +-
> fs/cifs/cifs_debug.c   |  280 ++++----
> fs/cifs/cifs_dfs_ref.c |  451 +++++++++++++
> fs/cifs/cifs_fs_sb.h   |   16 +-
> fs/cifs/cifs_unicode.c |   12 +-
> fs/cifs/cifs_unicode.h |   53 +-
> fs/cifs/cifs_uniupr.h  |    8 +-
> fs/cifs/cifsacl.h      |    4 +-
> fs/cifs/cifsencrypt.c  |  262 ++++----
> fs/cifs/cifsencrypt.h  |    2 -
> fs/cifs/cifsfs.c       |  524 +++++++++------
> fs/cifs/cifsfs.h       |   31 +-
> fs/cifs/cifsglob.h     |   88 ++-
> fs/cifs/cifspdu.h      |  337 ++++++----
> fs/cifs/cifsproto.h    |  133 ++--
> fs/cifs/cifssmb.c      | 1759 +++++++++++++++++++++++++++---------------------
> fs/cifs/connect.c      | 1590 ++++++++++++++++++++++++-------------------
> fs/cifs/dir.c          |  202 +++---
> fs/cifs/export.c       |   54 +-
> fs/cifs/fcntl.c        |   55 +-
> fs/cifs/file.c         |  699 +++++++++++--------
> fs/cifs/inode.c        |  584 ++++++++++++-----
> fs/cifs/ioctl.c        |   47 +-
> fs/cifs/link.c         |  122 ++--
> fs/cifs/md4.c          |   10 +-
> fs/cifs/md5.c          |   16 +-
> fs/cifs/md5.h          |    8 +-
> fs/cifs/misc.c         |  249 ++++----
> fs/cifs/netmisc.c      |  121 ++--
> fs/cifs/nterr.c        |    8 +-
> fs/cifs/nterr.h        |    8 +-
> fs/cifs/ntlmssp.h      |   22 +-
> fs/cifs/readdir.c      |  602 +++++++++--------
> fs/cifs/rfc1002pdu.h   |    2 +-
> fs/cifs/sess.c         |  273 ++++----
> fs/cifs/smbdes.c       |   36 +-
> fs/cifs/smbencrypt.c   |   63 +-
> fs/cifs/smberr.h       |    8 +-
> fs/cifs/transport.c    |  284 ++++----
> fs/cifs/xattr.c        |  229 ++++---
> 43 files changed, 5602 insertions(+), 3940 deletions(-)
> create mode 100644 fs/cifs/cifs_dfs_ref.c
>
>diff --git a/fs/cifs/CHANGES b/fs/cifs/CHANGES
>index 5072b17..41e3b6a 100644
>--- a/fs/cifs/CHANGES
>+++ b/fs/cifs/CHANGES
>@@ -1,4 +1,33 @@
>-Verison 1.48
>+Version 1.50
>+------------
>+Fix NTLMv2 signing. NFS server mounted over cifs works (if cifs mount is
>+done with "serverino" mount option).  Add support for POSIX Unlink
>+(helps with certain sharing violation cases when server such as
>+Samba supports newer POSIX CIFS Protocol Extensions). Add "nounix"
>+mount option to allow disabling the CIFS Unix Extensions for just
>+that mount. Fix hang on spinlock in find_writable_file (race when
>+reopening file after session crash).  Byte range unlock request to
>+windows server could unlock more bytes (on server copy of file)
>+than intended if start of unlock request is well before start of
>+a previous byte range lock that we issued.
>+
>+Version 1.49
>+------------
>+IPv6 support.  Enable ipv6 addresses to be passed on mount (put the ipv6
>+address after the "ip=" mount option, at least until mount.cifs is fixed to
>+handle DNS host to ipv6 name translation).  Accept override of uid or gid
>+on mount even when Unix Extensions are negotiated (it used to be ignored
>+when Unix Extensions were ignored).  This allows users to override the
>+default uid and gid for files when they are certain that the uids or
>+gids on the server do not match those of the client.  Make "sec=none"
>+mount override username (so that null user connection is attempted)
>+to match what documentation said. Support for very large reads, over 127K,
>+available to some newer servers (such as Samba 3.0.26 and later but
>+note that it also requires setting CIFSMaxBufSize at module install
>+time to a larger value which may hurt performance in some cases).
>+Make sign option force signing (or fail if server does not support it).
>+
>+Version 1.48
> ------------
> Fix mtime bouncing around from local idea of last write times to remote time.
> Fix hang (in i_size_read) when simultaneous size update of same remote file
>@@ -9,7 +38,13 @@ from read-only back to read-write, reflect this change in default file mode
> (we had been leaving a file's mode read-only until the inode were reloaded).
> Allow setting of attribute back to ATTR_NORMAL (removing readonly dos attribute
> when archive dos attribute not set and we are changing mode back to writeable
>-on server which does not support the Unix Extensions).
>+on server which does not support the Unix Extensions).  Remove read only dos
>+attribute on chmod when adding any write permission (ie on any of
>+user/group/other (not all of user/group/other ie  0222) when
>+mounted to windows.  Add support for POSIX MkDir (slight performance
>+enhancement and eliminates the network race between the mkdir and set 
>+path info of the mode).
>+
> 
> Version 1.47
> ------------
>@@ -17,7 +52,12 @@ Fix oops in list_del during mount caused by unaligned string.
> Fix file corruption which could occur on some large file
> copies caused by writepages page i/o completion bug.
> Seek to SEEK_END forces check for update of file size for non-cached
>-files.
>+files. Allow file size to be updated on remote extend of locally open,
>+non-cached file.  Fix reconnect to newer Samba servers (or other servers
>+which support the CIFS Unix/POSIX extensions) so that we again tell the
>+server the Unix/POSIX cifs capabilities which we support (SetFSInfo).
>+Add experimental support for new POSIX Open/Mkdir (which returns
>+stat information on the open, and allows setting the mode).
> 
> Version 1.46
> ------------
>@@ -246,7 +286,7 @@ improperly zeroed buffer in CIFS Unix extensions set times call.
> Version 1.25
> ------------
> Fix internationalization problem in cifs readdir with filenames that map to 
>-longer UTF8 strings than the string on the wire was in Unicode.  Add workaround
>+longer UTF-8 strings than the string on the wire was in Unicode.  Add workaround
> for readdir to netapp servers. Fix search rewind (seek into readdir to return 
> non-consecutive entries).  Do not do readdir when server negotiates 
> buffer size to small to fit filename. Add support for reading POSIX ACLs from
>diff --git a/fs/cifs/README b/fs/cifs/README
>index d4be92b..b806b11 100644
>--- a/fs/cifs/README
>+++ b/fs/cifs/README
>@@ -257,19 +257,25 @@ A partial list of the supported mount options follows:
> 		mount.	
>   domain	Set the SMB/CIFS workgroup name prepended to the
> 		username during CIFS session establishment
>-  uid		If CIFS Unix extensions are not supported by the server
>-		this overrides the default uid for inodes. For mounts to
>-		servers which do support the CIFS Unix extensions, such
>-		as a properly configured Samba server, the server provides
>-		the uid, gid and mode.  For servers which do not support
>-		the Unix extensions, the default uid (and gid) returned on
>-		lookup of existing files is the uid (gid) of the person
>+  uid		Set the default uid for inodes. For mounts to servers
>+		which do support the CIFS Unix extensions, such as a
>+		properly configured Samba server, the server provides
>+		the uid, gid and mode so this parameter should  not be
>+		specified unless the server and clients uid and gid
>+		numbering differ.  If the server and client are in the
>+		same domain (e.g. running winbind or nss_ldap) and
>+		the server supports the Unix Extensions then the uid
>+		and gid can be retrieved from the server (and uid
>+		and gid would not have to be specifed on the mount. 
>+		For servers which do not support the CIFS Unix
>+		extensions, the default uid (and gid) returned on lookup
>+		of existing files will be the uid (gid) of the person
> 		who executed the mount (root, except when mount.cifs
> 		is configured setuid for user mounts) unless the "uid=" 
> 		(gid) mount option is specified.  For the uid (gid) of newly
> 		created files and directories, ie files created since 
> 		the last mount of the server share, the expected uid 
>-		(gid) is cached as as long as the inode remains in 
>+		(gid) is cached as long as the inode remains in 
> 		memory on the client.   Also note that permission
> 		checks (authorization checks) on accesses to a file occur
> 		at the server, but there are cases in which an administrator
>@@ -281,8 +287,7 @@ A partial list of the supported mount options follows:
> 		the client.  Note that the mount.cifs helper must be
> 		at version 1.10 or higher to support specifying the uid
> 		(or gid) in non-numberic form.
>-  gid		If CIFS Unix extensions are not supported by the server
>-		this overrides the default gid for inodes.
>+  gid		Set the default gid for inodes (similar to above).
>   file_mode     If CIFS Unix extensions are not supported by the server
> 		this overrides the default mode for file inodes.
>   dir_mode      If CIFS Unix extensions are not supported by the server 
>@@ -296,10 +301,21 @@ A partial list of the supported mount options follows:
> 		during the local client kernel build will be used.
> 		If server does not support Unicode, this parameter is
> 		unused.
>-  rsize		default read size (usually 16K)
>-  wsize		default write size (usually 16K, 32K is often better over GigE)
>-		maximum wsize currently allowed by CIFS is 57344 (14 4096 byte
>-		pages)
>+  rsize		default read size (usually 16K). The client currently
>+		can not use rsize larger than CIFSMaxBufSize. CIFSMaxBufSize
>+		defaults to 16K and may be changed (from 8K to the maximum
>+		kmalloc size allowed by your kernel) at module install time
>+		for cifs.ko. Setting CIFSMaxBufSize to a very large value
>+		will cause cifs to use more memory and may reduce performance
>+		in some cases.  To use rsize greater than 127K (the original
>+		cifs protocol maximum) also requires that the server support
>+		a new Unix Capability flag (for very large read) which some
>+		newer servers (e.g. Samba 3.0.26 or later) do. rsize can be
>+		set from a minimum of 2048 to a maximum of 130048 (127K or
>+		CIFSMaxBufSize, whichever is smaller)
>+  wsize		default write size (default 57344)
>+		maximum wsize currently allowed by CIFS is 57344 (fourteen
>+		4096 byte pages)
>   rw		mount the network share read-write (note that the
> 		server may still consider the share read-only)
>   ro		mount network share read-only
>@@ -354,7 +370,7 @@ A partial list of the supported mount options follows:
> 		Note that this does not affect the normal ACL check on the
> 		target machine done by the server software (of the server
> 		ACL against the user name provided at mount time).
>-  serverino	Use servers inode numbers instead of generating automatically
>+  serverino	Use server's inode numbers instead of generating automatically
> 		incrementing inode numbers on the client.  Although this will
> 		make it easier to spot hardlinked files (as they will have
> 		the same inode numbers) and inode numbers may be persistent,
>@@ -362,12 +378,11 @@ A partial list of the supported mount options follows:
> 		are unique if multiple server side mounts are exported under a
> 		single share (since inode numbers on the servers might not
> 		be unique if multiple filesystems are mounted under the same
>-		shared higher level directory).  Note that this requires that
>-		the server support the CIFS Unix Extensions as other servers
>-		do not return a unique IndexNumber on SMB FindFirst (most
>-		servers return zero as the IndexNumber).  Parameter has no
>-		effect to Windows servers and others which do not support the
>-		CIFS Unix Extensions.
>+		shared higher level directory).  Note that some older
>+		(e.g. pre-Windows 2000) do not support returning UniqueIDs
>+		or the CIFS Unix Extensions equivalent and for those
>+		this mount option will have no effect.  Exporting cifs mounts
>+		under nfsd requires this mount option on the cifs mount.
>   noserverino   Client generates inode numbers (rather than using the actual one
> 		from the server) by default.
>   setuids       If the CIFS Unix extensions are negotiated with the server
>@@ -375,7 +390,7 @@ A partial list of the supported mount options follows:
> 		the local process on newly created files, directories, and
> 		devices (create, mkdir, mknod).  If the CIFS Unix Extensions
> 		are not negotiated, for newly created files and directories
>-		instead of using the default uid and gid specified on the
>+		instead of using the default uid and gid specified on
> 		the mount, cache the new file's uid and gid locally which means
> 		that the uid for the file can change when the inode is
> 	        reloaded (or the user remounts the share).
>@@ -429,6 +444,13 @@ A partial list of the supported mount options follows:
>  noposixpaths   If CIFS Unix extensions are supported, do not request
> 		posix path name support (this may cause servers to
> 		reject creatingfile with certain reserved characters).
>+ nounix         Disable the CIFS Unix Extensions for this mount (tree
>+		connection). This is rarely needed, but it may be useful
>+		in order to turn off multiple settings all at once (ie
>+		posix acls, posix locks, posix paths, symlink support
>+		and retrieving uids/gids/mode from the server) or to
>+		work around a bug in server which implement the Unix
>+		Extensions.
>  nobrl          Do not send byte range lock requests to the server.
> 		This is necessary for certain applications that break
> 		with cifs style mandatory byte range locks (and most
>@@ -436,11 +458,17 @@ A partial list of the supported mount options follows:
> 		byte range locks).
>  remount        remount the share (often used to change from ro to rw mounts
> 	        or vice versa)
>+ servern        Specify the server 's netbios name (RFC1001 name) to use
>+		when attempting to setup a session to the server.  This is
>+		This is needed for mounting to some older servers (such
>+		as OS/2 or Windows 98 and Windows ME) since they do not
>+		support a default server name.  A server name can be up
>+		to 15 characters long and is usually uppercased.
>  sfu            When the CIFS Unix Extensions are not negotiated, attempt to
> 		create device files and fifos in a format compatible with
> 		Services for Unix (SFU).  In addition retrieve bits 10-12
> 		of the mode via the SETFILEBITS extended attribute (as
>-		SFU does).  In the future the bottom 9 bits of the mode
>+		SFU does).  In the future the bottom 9 bits of the
> 		mode also will be emulated using queries of the security
> 		descriptor (ACL).
>  sign           Must use packet signing (helps avoid unwanted data modification
>@@ -467,7 +495,7 @@ including:
> 	-V      print mount.cifs version
> 	-?      display simple usage information
> 
>-With recent 2.6 kernel versions of modutils, the version of the cifs kernel
>+With most 2.6 kernel versions of modutils, the version of the cifs kernel
> module can be displayed via modinfo.
> 
> Misc /proc/fs/cifs Flags and Debug Info
>@@ -516,8 +544,22 @@ SecurityFlags		Flags which control security negotiation and
> 			must use plaintext passwords			0x20020
> 			(reserved for future packet encryption)		0x00040
> 
>-cifsFYI			If set to one, additional debug information is
>-			logged to the system error log. (default 0)
>+cifsFYI			If set to non-zero value, additional debug information
>+			will be logged to the system error log.  This field
>+			contains three flags controlling different classes of
>+			debugging entries.  The maximum value it can be set
>+			to is 7 which enables all debugging points (default 0).
>+			Some debugging statements are not compiled into the
>+			cifs kernel unless CONFIG_CIFS_DEBUG2 is enabled in the
>+			kernel configuration. cifsFYI may be set to one or
>+			nore of the following flags (7 sets them all):
>+
>+			log cifs informational messages			0x01
>+			log return codes from cifs entry points		0x02
>+			log slow responses (ie which take longer than 1 second)
>+			  CONFIG_CIFS_STATS2 must be enabled in .config	0x04
>+				
>+				
> traceSMB		If set to one, debug information is logged to the
> 			system error log with the start of smb requests
> 			and responses (default 0)
>@@ -563,10 +605,10 @@ the start of smb requests and responses can be enabled via:
> 
> 	echo 1 > /proc/fs/cifs/traceSMB
> 
>-Two other experimental features are under development and to test 
>-require enabling CONFIG_CIFS_EXPERIMENTAL
>+Two other experimental features are under development. To test these
>+requires enabling CONFIG_CIFS_EXPERIMENTAL
> 
>-	More efficient write operations
>+	ipv6 enablement
> 
> 	DNOTIFY fcntl: needed for support of directory change 
> 			    notification and perhaps later for file leases)
>diff --git a/fs/cifs/TODO b/fs/cifs/TODO
>index 267a762..29d4b27 100644
>--- a/fs/cifs/TODO
>+++ b/fs/cifs/TODO
>@@ -1,4 +1,4 @@
>-Version 1.39 November 30, 2005
>+Version 1.49 April 26, 2007
> 
> A Partial List of Missing Features
> ==================================
>@@ -18,64 +18,53 @@ better)
> 
> d) Kerberos/SPNEGO session setup support - (started)
> 
>-e) NTLMv2 authentication (mostly implemented - double check
>-that NTLMv2 signing works, also need to cleanup now unneeded SessSetup code in
>-fs/cifs/connect.c)
>+e) Cleanup now unneeded SessSetup code in
>+fs/cifs/connect.c and add back in NTLMSSP code if any servers
>+need it
> 
> f) MD5-HMAC signing SMB PDUs when SPNEGO style SessionSetup 
> used (Kerberos or NTLMSSP). Signing alreadyimplemented for NTLM
> and raw NTLMSSP already. This is important when enabling
> extended security and mounting to Windows 2003 Servers
> 
>-f) Directory entry caching relies on a 1 second timer, rather than 
>+g) Directory entry caching relies on a 1 second timer, rather than 
> using FindNotify or equivalent.  - (started)
> 
>-g) A few byte range testcases fail due to POSIX vs. Windows/CIFS
>-style byte range lock differences.  Save byte range locks so
>-reconnect can replay them.  
>-
>-h) Support unlock all (unlock 0,MAX_OFFSET)
>-by unlocking all known byte range locks that we locked on the file.
>-
>-i) quota support (needs minor kernel change since quota calls
>+h) quota support (needs minor kernel change since quota calls
> to make it to network filesystems or deviceless filesystems)
> 
>-j) investigate sync behavior (including syncpage) and check  
>+i) investigate sync behavior (including syncpage) and check  
> for proper behavior of intr/nointr
> 
>-k) hook lower into the sockets api (as NFS/SunRPC does) to avoid the
>+j) hook lower into the sockets api (as NFS/SunRPC does) to avoid the
> extra copy in/out of the socket buffers in some cases.
> 
>-l) finish support for IPv6.  This is mostly complete but
>-needs a simple conversion of ipv6 to sin6_addr from the
>-address in string representation.
>-
>-m) Better optimize open (and pathbased setfilesize) to reduce the
>+k) Better optimize open (and pathbased setfilesize) to reduce the
> oplock breaks coming from windows srv.  Piggyback identical file
> opens on top of each other by incrementing reference count rather
> than resending (helps reduce server resource utilization and avoid
> spurious oplock breaks).
> 
>-o) Improve performance of readpages by sending more than one read
>+l) Improve performance of readpages by sending more than one read
> at a time when 8 pages or more are requested. In conjuntion
> add support for async_cifs_readpages.
> 
>-p) Add support for storing symlink info to Windows servers 
>+m) Add support for storing symlink info to Windows servers 
> in the Extended Attribute format their SFU clients would recognize.
> 
>-q) Finish fcntl D_NOTIFY support so kde and gnome file list windows
>+n) Finish fcntl D_NOTIFY support so kde and gnome file list windows
> will autorefresh (partially complete by Asser). Needs minor kernel
> vfs change to support removing D_NOTIFY on a file.   
> 
>-r) Add GUI tool to configure /proc/fs/cifs settings and for display of
>+o) Add GUI tool to configure /proc/fs/cifs settings and for display of
> the CIFS statistics (started)
> 
>-s) implement support for security and trusted categories of xattrs
>+p) implement support for security and trusted categories of xattrs
> (requires minor protocol extension) to enable better support for SELINUX
> 
>-t) Implement O_DIRECT flag on open (already supported on mount)
>+q) Implement O_DIRECT flag on open (already supported on mount)
> 
>-u) Create UID mapping facility so server UIDs can be mapped on a per
>+r) Create UID mapping facility so server UIDs can be mapped on a per
> mount or a per server basis to client UIDs or nobody if no mapping
> exists.  This is helpful when Unix extensions are negotiated to
> allow better permission checking when UIDs differ on the server
>@@ -83,19 +72,25 @@ and client.  Add new protocol request to the CIFS protocol
> standard for asking the server for the corresponding name of a
> particular uid.
> 
>-v) Add support for CIFS Unix and also the newer POSIX extensions to the
>+s) Add support for CIFS Unix and also the newer POSIX extensions to the
> server side for Samba 4.
> 
>-w) Finish up the dos time conversion routines needed to return old server
>-time to the client (default time, of now or time 0 is used now for these 
>-very old servers)
>-
>-x) In support for OS/2 (LANMAN 1.2 and LANMAN2.1 based SMB servers) 
>+t) In support for OS/2 (LANMAN 1.2 and LANMAN2.1 based SMB servers) 
> need to add ability to set time to server (utimes command)
> 
>-y) Finish testing of Windows 9x/Windows ME server support (started).
>+u) DOS attrs - returned as pseudo-xattr in Samba format (check VFAT and NTFS for this too)
>+
>+v) mount check for unmatched uids
> 
>-KNOWN BUGS (updated February 26, 2007)
>+w) Add support for new vfs entry points for setlease and fallocate 
>+
>+x) Fix Samba 3 server to handle Linux kernel aio so dbench with lots of 
>+processes can proceed better in parallel (on the server)
>+
>+y) Fix Samba 3 to handle reads/writes over 127K (and remove the cifs mount
>+restriction of wsize max being 127K) 
>+
>+KNOWN BUGS (updated April 24, 2007)
> ====================================
> See http://bugzilla.samba.org - search on product "CifsVFS" for
> current bug list.
>@@ -110,6 +105,12 @@ but recognizes them
> succeed but still return access denied (appears to be Windows 
> server not cifs client problem) and has not been reproduced recently.
> NTFS partitions do not have this problem.
>+4) Unix/POSIX capabilities are reset after reconnection, and affect
>+a few fields in the tree connection but we do do not know which
>+superblocks to apply these changes to.  We should probably walk
>+the list of superblocks to set these.  Also need to check the
>+flags on the second mount to the same share, and see if we
>+can do the same trick that NFS does to remount duplicate shares.
> 
> Misc testing to do
> ==================
>@@ -126,3 +127,4 @@ negotiated size) and send larger write sizes to modern servers.
> 
> 4) More exhaustively test against less common servers.  More testing
> against Windows 9x, Windows ME servers.
>+
>diff --git a/fs/cifs/asn1.c b/fs/cifs/asn1.c
>index 2e75883..389640e 100644
>--- a/fs/cifs/asn1.c
>+++ b/fs/cifs/asn1.c
>@@ -1,7 +1,7 @@
>-/* 
>+/*
>  * The ASB.1/BER parsing code is derived from ip_nat_snmp_basic.c which was in
>  * turn derived from the gxsnmp package by Gregory McLean & Jochen Friedrich
>- *      
>+ *
>  * Copyright (c) 2000 RP Internet (www.rpi.net.au).
>  *
>  * This program is free software; you can redistribute it and/or modify
>@@ -26,6 +26,9 @@
> #include "cifsglob.h"
> #include "cifs_debug.h"
> #include "cifsproto.h"
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
>+#include <linux/config.h>
>+#endif
> 
> /*****************************************************************************
>  *
>@@ -80,7 +83,7 @@
> static unsigned long SPNEGO_OID[7] = { 1, 3, 6, 1, 5, 5, 2 };
> static unsigned long NTLMSSP_OID[10] = { 1, 3, 6, 1, 4, 1, 311, 2, 2, 10 };
> 
>-/* 
>+/*
>  * ASN.1 context.
>  */
> struct asn1_ctx {
>@@ -190,7 +193,7 @@ asn1_header_decode(struct asn1_ctx *ctx,
> 		   unsigned char **eoc,
> 		   unsigned int *cls, unsigned int *con, unsigned int *tag)
> {
>-	unsigned int def = 0; 
>+	unsigned int def = 0;
> 	unsigned int len = 0;
> 
> 	if (!asn1_id_decode(ctx, cls, con, tag))
>@@ -331,7 +334,7 @@ static unsigned char asn1_ulong_decode(struct asn1_ctx *ctx,
> 		*integer |= ch;
> 	}
> 	return 1;
>-} 
>+}
> 
> static unsigned char
> asn1_octets_decode(struct asn1_ctx *ctx,
>@@ -376,7 +379,7 @@ asn1_subid_decode(struct asn1_ctx *ctx, unsigned long *subid)
> 	return 1;
> }
> 
>-static int 
>+static int
> asn1_oid_decode(struct asn1_ctx *ctx,
> 		unsigned char *eoc, unsigned long **oid, unsigned int *len)
> {
>@@ -385,10 +388,9 @@ asn1_oid_decode(struct asn1_ctx *ctx,
> 	unsigned long *optr;
> 
> 	size = eoc - ctx->pointer + 1;
>-	*oid = kmalloc(size * sizeof (unsigned long), GFP_ATOMIC);
>-	if (*oid == NULL) {
>+	*oid = kmalloc(size * sizeof(unsigned long), GFP_ATOMIC);
>+	if (*oid == NULL)
> 		return 0;
>-	}
> 
> 	optr = *oid;
> 
>@@ -459,7 +461,7 @@ decode_negTokenInit(unsigned char *security_blob, int length,
> 	unsigned int cls, con, tag, oidlen, rc;
> 	int use_ntlmssp = FALSE;
> 
>-	*secType = NTLM; /* BB eventually make Kerberos or NLTMSSP the default */
>+	*secType = NTLM; /* BB eventually make Kerberos or NLTMSSP the default*/
> 
> 	/* cifs_dump_mem(" Received SecBlob ", security_blob, length); */
> 
>@@ -498,7 +500,8 @@ decode_negTokenInit(unsigned char *security_blob, int length,
> 			return 0;
> 		} else if ((cls != ASN1_CTX) || (con != ASN1_CON)
> 			   || (tag != ASN1_EOC)) {
>-			cFYI(1,("cls = %d con = %d tag = %d end = %p (%d) exit 0",
>+			cFYI(1,
>+			     ("cls = %d con = %d tag = %d end = %p (%d) exit 0",
> 			      cls, con, tag, end, *end));
> 			return 0;
> 		}
>@@ -508,7 +511,8 @@ decode_negTokenInit(unsigned char *security_blob, int length,
> 			return 0;
> 		} else if ((cls != ASN1_UNI) || (con != ASN1_CON)
> 			   || (tag != ASN1_SEQ)) {
>-			cFYI(1,("cls = %d con = %d tag = %d end = %p (%d) exit 1",
>+			cFYI(1,
>+			     ("cls = %d con = %d tag = %d end = %p (%d) exit 1",
> 			      cls, con, tag, end, *end));
> 			return 0;
> 		}
>@@ -540,32 +544,34 @@ decode_negTokenInit(unsigned char *security_blob, int length,
> 			rc = asn1_header_decode(&ctx, &end, &cls, &con, &tag);
> 			if (!rc) {
> 				cFYI(1,
>-				     ("Error 1 decoding negTokenInit header exit 2"));
>+				     ("Error decoding negTokenInit hdr exit2"));
> 				return 0;
> 			}
> 			if ((tag == ASN1_OJI) && (con == ASN1_PRI)) {
> 				rc = asn1_oid_decode(&ctx, end, &oid, &oidlen);
>-				if(rc) {		
>+				if (rc) {
> 					cFYI(1,
>-					  ("OID len = %d oid = 0x%lx 0x%lx 0x%lx 0x%lx",
>-					   oidlen, *oid, *(oid + 1), *(oid + 2),
>-					   *(oid + 3)));
>-					rc = compare_oid(oid, oidlen, NTLMSSP_OID,
>-						 NTLMSSP_OID_LEN);
>+					  ("OID len = %d oid = 0x%lx 0x%lx "
>+					   "0x%lx 0x%lx",
>+					   oidlen, *oid, *(oid + 1),
>+					   *(oid + 2), *(oid + 3)));
>+					rc = compare_oid(oid, oidlen,
>+						 NTLMSSP_OID, NTLMSSP_OID_LEN);
> 					kfree(oid);
> 					if (rc)
> 						use_ntlmssp = TRUE;
> 				}
> 			} else {
>-				cFYI(1,("This should be an oid what is going on? "));
>+				cFYI(1, ("Should be an oid what is going on?"));
> 			}
> 		}
> 
> 		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
> 			cFYI(1,
>-			     ("Error decoding last part of negTokenInit exit 3"));
>+			     ("Error decoding last part negTokenInit exit3"));
> 			return 0;
>-		} else if ((cls != ASN1_CTX) || (con != ASN1_CON)) {	/* tag = 3 indicating mechListMIC */
>+		} else if ((cls != ASN1_CTX) || (con != ASN1_CON)) {
>+			/* tag = 3 indicating mechListMIC */
> 			cFYI(1,
> 			     ("Exit 4 cls = %d con = %d tag = %d end = %p (%d)",
> 			      cls, con, tag, end, *end));
>@@ -573,18 +579,17 @@ decode_negTokenInit(unsigned char *security_blob, int length,
> 		}
> 		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
> 			cFYI(1,
>-			     ("Error decoding last part of negTokenInit exit 5"));
>+			     ("Error decoding last part negTokenInit exit5"));
> 			return 0;
> 		} else if ((cls != ASN1_UNI) || (con != ASN1_CON)
> 			   || (tag != ASN1_SEQ)) {
>-			cFYI(1,
>-			     ("Exit 6 cls = %d con = %d tag = %d end = %p (%d)",
>-			      cls, con, tag, end, *end));
>+			cFYI(1, ("cls = %d con = %d tag = %d end = %p (%d)",
>+				cls, con, tag, end, *end));
> 		}
> 
> 		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
> 			cFYI(1,
>-			     ("Error decoding last part of negTokenInit exit 7"));
>+			     ("Error decoding last part negTokenInit exit 7"));
> 			return 0;
> 		} else if ((cls != ASN1_CTX) || (con != ASN1_CON)) {
> 			cFYI(1,
>@@ -594,20 +599,21 @@ decode_negTokenInit(unsigned char *security_blob, int length,
> 		}
> 		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
> 			cFYI(1,
>-			     ("Error decoding last part of negTokenInit exit 9"));
>+			     ("Error decoding last part negTokenInit exit9"));
> 			return 0;
> 		} else if ((cls != ASN1_UNI) || (con != ASN1_PRI)
> 			   || (tag != ASN1_GENSTR)) {
> 			cFYI(1,
>-			     ("Exit 10 cls = %d con = %d tag = %d end = %p (%d)",
>+			     ("Exit10 cls = %d con = %d tag = %d end = %p (%d)",
> 			      cls, con, tag, end, *end));
> 			return 0;
> 		}
>-		cFYI(1, ("Need to call asn1_octets_decode() function for this %s", ctx.pointer));	/* is this UTF-8 or ASCII? */
>+		cFYI(1, ("Need to call asn1_octets_decode() function for %s",
>+			 ctx.pointer));	/* is this UTF-8 or ASCII? */
> 	}
> 
>-	/* if (use_kerberos) 
>-	   *secType = Kerberos 
>+	/* if (use_kerberos)
>+	   *secType = Kerberos
> 	   else */
> 	if (use_ntlmssp) {
> 		*secType = NTLMSSP;
>diff --git a/fs/cifs/cifs_debug.c b/fs/cifs/cifs_debug.c
>index a261954..56c5d91 100644
>--- a/fs/cifs/cifs_debug.c
>+++ b/fs/cifs/cifs_debug.c
>@@ -7,16 +7,16 @@
>  *
>  *   This program is free software;  you can redistribute it and/or modify
>  *   it under the terms of the GNU General Public License as published by
>- *   the Free Software Foundation; either version 2 of the License, or 
>+ *   the Free Software Foundation; either version 2 of the License, or
>  *   (at your option) any later version.
>- * 
>+ *
>  *   This program is distributed in the hope that it will be useful,
>  *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
>  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
>  *   the GNU General Public License for more details.
>  *
>  *   You should have received a copy of the GNU General Public License
>- *   along with this program;  if not, write to the Free Software 
>+ *   along with this program;  if not, write to the Free Software
>  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>  */
> #include <linux/fs.h>
>@@ -39,7 +39,7 @@ cifs_dump_mem(char *label, void *data, int length)
> 	char *charptr = data;
> 	char buf[10], line[80];
> 
>-	printk(KERN_DEBUG "%s: dump of %d bytes of data at 0x%p\n", 
>+	printk(KERN_DEBUG "%s: dump of %d bytes of data at 0x%p\n",
> 		label, length, data);
> 	for (i = 0; i < length; i += 16) {
> 		line[0] = 0;
>@@ -58,50 +58,49 @@ cifs_dump_mem(char *label, void *data, int length)
> }
> 
> #ifdef CONFIG_CIFS_DEBUG2
>-void cifs_dump_detail(struct smb_hdr * smb)
>+void cifs_dump_detail(struct smb_hdr *smb)
> {
>-	cERROR(1,("Cmd: %d Err: 0x%x Flags: 0x%x Flgs2: 0x%x Mid: %d Pid: %d",
>+	cERROR(1, ("Cmd: %d Err: 0x%x Flags: 0x%x Flgs2: 0x%x Mid: %d Pid: %d",
> 		  smb->Command, smb->Status.CifsError,
> 		  smb->Flags, smb->Flags2, smb->Mid, smb->Pid));
>-	cERROR(1,("smb buf %p len %d", smb, smbCalcSize_LE(smb)));
>+	cERROR(1, ("smb buf %p len %d", smb, smbCalcSize_LE(smb)));
> }
> 
> 
>-void cifs_dump_mids(struct TCP_Server_Info * server)
>+void cifs_dump_mids(struct TCP_Server_Info *server)
> {
> 	struct list_head *tmp;
>-	struct mid_q_entry * mid_entry;
>+	struct mid_q_entry *mid_entry;
> 
>-	if(server == NULL)
>+	if (server == NULL)
> 		return;
> 
>-	cERROR(1,("Dump pending requests:"));
>+	cERROR(1, ("Dump pending requests:"));
> 	spin_lock(&GlobalMid_Lock);
> 	list_for_each(tmp, &server->pending_mid_q) {
> 		mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
>-		if(mid_entry) {
>-			cERROR(1,("State: %d Cmd: %d Pid: %d Tsk: %p Mid %d",
>+		if (mid_entry) {
>+			cERROR(1, ("State: %d Cmd: %d Pid: %d Tsk: %p Mid %d",
> 				mid_entry->midState,
> 				(int)mid_entry->command,
> 				mid_entry->pid,
> 				mid_entry->tsk,
> 				mid_entry->mid));
> #ifdef CONFIG_CIFS_STATS2
>-			cERROR(1,("IsLarge: %d buf: %p time rcv: %ld now: %ld",
>+			cERROR(1, ("IsLarge: %d buf: %p time rcv: %ld now: %ld",
> 				mid_entry->largeBuf,
> 				mid_entry->resp_buf,
> 				mid_entry->when_received,
> 				jiffies));
> #endif /* STATS2 */
>-			cERROR(1,("IsMult: %d IsEnd: %d", mid_entry->multiRsp,
>+			cERROR(1, ("IsMult: %d IsEnd: %d", mid_entry->multiRsp,
> 				  mid_entry->multiEnd));
>-			if(mid_entry->resp_buf) {
>+			if (mid_entry->resp_buf) {
> 				cifs_dump_detail(mid_entry->resp_buf);
> 				cifs_dump_mem("existing buf: ",
> 					mid_entry->resp_buf,
> 					62 /* fixme */);
> 			}
>-			
> 		}
> 	}
> 	spin_unlock(&GlobalMid_Lock);
>@@ -115,12 +114,12 @@ cifs_debug_data_read(char *buf, char **beginBuffer, off_t offset,
> {
> 	struct list_head *tmp;
> 	struct list_head *tmp1;
>-	struct mid_q_entry * mid_entry;
>+	struct mid_q_entry *mid_entry;
> 	struct cifsSesInfo *ses;
> 	struct cifsTconInfo *tcon;
> 	int i;
> 	int length = 0;
>-	char * original_buf = buf;
>+	char *original_buf = buf;
> 
> 	*beginBuffer = buf + offset;
> 
>@@ -129,9 +128,10 @@ cifs_debug_data_read(char *buf, char **beginBuffer, off_t offset,
> 		    "Display Internal CIFS Data Structures for Debugging\n"
> 		    "---------------------------------------------------\n");
> 	buf += length;
>-	length = sprintf(buf,"CIFS Version %s\n",CIFS_VERSION);
>+	length = sprintf(buf, "CIFS Version %s\n", CIFS_VERSION);
> 	buf += length;
>-	length = sprintf(buf,"Active VFS Requests: %d\n", GlobalTotalActiveXid);
>+	length = sprintf(buf,
>+		"Active VFS Requests: %d\n", GlobalTotalActiveXid);
> 	buf += length;
> 	length = sprintf(buf, "Servers:");
> 	buf += length;
>@@ -141,23 +141,25 @@ cifs_debug_data_read(char *buf, char **beginBuffer, off_t offset,
> 	list_for_each(tmp, &GlobalSMBSessionList) {
> 		i++;
> 		ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
>-		if((ses->serverDomain == NULL) || (ses->serverOS == NULL) ||
>+		if ((ses->serverDomain == NULL) || (ses->serverOS == NULL) ||
> 		   (ses->serverNOS == NULL)) {
> 			buf += sprintf(buf, "\nentry for %s not fully "
> 					"displayed\n\t", ses->serverName);
>-			
> 		} else {
> 			length =
> 			    sprintf(buf,
>-				    "\n%d) Name: %s  Domain: %s Mounts: %d OS: %s  \n\tNOS: %s\tCapability: 0x%x\n\tSMB session status: %d\t",
>+				    "\n%d) Name: %s  Domain: %s Mounts: %d OS:"
>+				    " %s  \n\tNOS: %s\tCapability: 0x%x\n\tSMB"
>+				    " session status: %d\t",
> 				i, ses->serverName, ses->serverDomain,
> 				atomic_read(&ses->inUse),
> 				ses->serverOS, ses->serverNOS,
>-				ses->capabilities,ses->status);
>+				ses->capabilities, ses->status);
> 			buf += length;
> 		}
>-		if(ses->server) {
>-			buf += sprintf(buf, "TCP status: %d\n\tLocal Users To Server: %d SecMode: 0x%x Req On Wire: %d",
>+		if (ses->server) {
>+			buf += sprintf(buf, "TCP status: %d\n\tLocal Users To "
>+				    "Server: %d SecMode: 0x%x Req On Wire: %d",
> 				ses->server->tcpStatus,
> 				atomic_read(&ses->server->socketUseCount),
> 				ses->server->secMode,
>@@ -165,7 +167,7 @@ cifs_debug_data_read(char *buf, char **beginBuffer, off_t offset,
> 
> #ifdef CONFIG_CIFS_STATS2
> 			buf += sprintf(buf, " In Send: %d In MaxReq Wait: %d",
>-				atomic_read(&ses->server->inSend), 
>+				atomic_read(&ses->server->inSend),
> 				atomic_read(&ses->server->num_waiters));
> #endif
> 
>@@ -177,17 +179,19 @@ cifs_debug_data_read(char *buf, char **beginBuffer, off_t offset,
> 				mid_entry = list_entry(tmp1, struct
> 					mid_q_entry,
> 					qhead);
>-				if(mid_entry) {
>-					length = sprintf(buf,"State: %d com: %d pid: %d tsk: %p mid %d\n",
>-						mid_entry->midState,
>-						(int)mid_entry->command,
>-						mid_entry->pid,
>-						mid_entry->tsk,
>-						mid_entry->mid);
>+				if (mid_entry) {
>+					length = sprintf(buf,
>+							"State: %d com: %d pid:"
>+							" %d tsk: %p mid %d\n",
>+							mid_entry->midState,
>+							(int)mid_entry->command,
>+							mid_entry->pid,
>+							mid_entry->tsk,
>+							mid_entry->mid);
> 					buf += length;
> 				}
> 			}
>-			spin_unlock(&GlobalMid_Lock); 
>+			spin_unlock(&GlobalMid_Lock);
> 		}
> 
> 	}
>@@ -205,17 +209,21 @@ cifs_debug_data_read(char *buf, char **beginBuffer, off_t offset,
> 		i++;
> 		tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
> 		dev_type = le32_to_cpu(tcon->fsDevInfo.DeviceType);
>-		length =
>-		    sprintf(buf,
>-			    "\n%d) %s Uses: %d Type: %s DevInfo: 0x%x Attributes: 0x%x\nPathComponentMax: %d Status: %d",
>-			    i, tcon->treeName,
>-			    atomic_read(&tcon->useCount),
>-			    tcon->nativeFileSystem,
>+		length = sprintf(buf, "\n%d) %s Uses: %d ", i,
>+				 tcon->treeName, atomic_read(&tcon->useCount));
>+		buf += length;
>+		if (tcon->nativeFileSystem) {
>+			length = sprintf(buf, "Type: %s ",
>+					 tcon->nativeFileSystem);
>+			buf += length;
>+		}
>+		length = sprintf(buf, "DevInfo: 0x%x Attributes: 0x%x"
>+				 "\nPathComponentMax: %d Status: %d",
> 			    le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics),
> 			    le32_to_cpu(tcon->fsAttrInfo.Attributes),
> 			    le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength),
> 			    tcon->tidStatus);
>-		buf += length;        
>+		buf += length;
> 		if (dev_type == FILE_DEVICE_DISK)
> 			length = sprintf(buf, " type: DISK ");
> 		else if (dev_type == FILE_DEVICE_CD_ROM)
>@@ -224,7 +232,7 @@ cifs_debug_data_read(char *buf, char **beginBuffer, off_t offset,
> 			length =
> 			    sprintf(buf, " type: %d ", dev_type);
> 		buf += length;
>-		if(tcon->tidStatus == CifsNeedReconnect) {
>+		if (tcon->tidStatus == CifsNeedReconnect) {
> 			buf += sprintf(buf, "\tDISCONNECTED ");
> 			length += 14;
> 		}
>@@ -238,9 +246,9 @@ cifs_debug_data_read(char *buf, char **beginBuffer, off_t offset,
> 	/* Now calculate total size of returned data */
> 	length = buf - original_buf;
> 
>-	if(offset + count >= length)
>+	if (offset + count >= length)
> 		*eof = 1;
>-	if(length < offset) {
>+	if (length < offset) {
> 		*eof = 1;
> 		return 0;
> 	} else {
>@@ -256,18 +264,18 @@ cifs_debug_data_read(char *buf, char **beginBuffer, off_t offset,
> 
> static int
> cifs_stats_write(struct file *file, const char __user *buffer,
>-               unsigned long count, void *data)
>+		 unsigned long count, void *data)
> {
>-        char c;
>-        int rc;
>+	char c;
>+	int rc;
> 	struct list_head *tmp;
> 	struct cifsTconInfo *tcon;
> 
>-        rc = get_user(c, buffer);
>-        if (rc)
>-                return rc;
>+	rc = get_user(c, buffer);
>+	if (rc)
>+		return rc;
> 
>-        if (c == '1' || c == 'y' || c == 'Y' || c == '0') {
>+	if (c == '1' || c == 'y' || c == 'Y' || c == '0') {
> 		read_lock(&GlobalSMBSeslock);
> #ifdef CONFIG_CIFS_STATS2
> 		atomic_set(&totBufAllocCount, 0);
>@@ -297,14 +305,14 @@ cifs_stats_write(struct file *file, const char __user *buffer,
> 		read_unlock(&GlobalSMBSeslock);
> 	}
> 
>-        return count;
>+	return count;
> }
> 
> static int
> cifs_stats_read(char *buf, char **beginBuffer, off_t offset,
> 		  int count, int *eof, void *data)
> {
>-	int item_length,i,length;
>+	int item_length, i, length;
> 	struct list_head *tmp;
> 	struct cifsTconInfo *tcon;
> 
>@@ -314,44 +322,44 @@ cifs_stats_read(char *buf, char **beginBuffer, off_t offset,
> 			"Resources in use\nCIFS Session: %d\n",
> 			sesInfoAllocCount.counter);
> 	buf += length;
>-	item_length = 
>-		sprintf(buf,"Share (unique mount targets): %d\n",
>+	item_length =
>+		sprintf(buf, "Share (unique mount targets): %d\n",
> 			tconInfoAllocCount.counter);
> 	length += item_length;
>-	buf += item_length;      
>-	item_length = 
>-		sprintf(buf,"SMB Request/Response Buffer: %d Pool size: %d\n",
>+	buf += item_length;
>+	item_length =
>+		sprintf(buf, "SMB Request/Response Buffer: %d Pool size: %d\n",
> 			bufAllocCount.counter,
> 			cifs_min_rcv + tcpSesAllocCount.counter);
> 	length += item_length;
> 	buf += item_length;
>-	item_length = 
>-		sprintf(buf,"SMB Small Req/Resp Buffer: %d Pool size: %d\n",
>-			smBufAllocCount.counter,cifs_min_small);
>+	item_length =
>+		sprintf(buf, "SMB Small Req/Resp Buffer: %d Pool size: %d\n",
>+			smBufAllocCount.counter, cifs_min_small);
> 	length += item_length;
> 	buf += item_length;
> #ifdef CONFIG_CIFS_STATS2
>-        item_length = sprintf(buf, "Total Large %d Small %d Allocations\n",
>+	item_length = sprintf(buf, "Total Large %d Small %d Allocations\n",
> 				atomic_read(&totBufAllocCount),
>-		                atomic_read(&totSmBufAllocCount));
>+				atomic_read(&totSmBufAllocCount));
> 	length += item_length;
> 	buf += item_length;
> #endif /* CONFIG_CIFS_STATS2 */
> 
>-	item_length = 
>-		sprintf(buf,"Operations (MIDs): %d\n",
>+	item_length =
>+		sprintf(buf, "Operations (MIDs): %d\n",
> 			midCount.counter);
> 	length += item_length;
> 	buf += item_length;
> 	item_length = sprintf(buf,
> 		"\n%d session %d share reconnects\n",
>-		tcpSesReconnectCount.counter,tconInfoReconnectCount.counter);
>+		tcpSesReconnectCount.counter, tconInfoReconnectCount.counter);
> 	length += item_length;
> 	buf += item_length;
> 
> 	item_length = sprintf(buf,
> 		"Total vfs operations: %d maximum at one time: %d\n",
>-		GlobalCurrentXid,GlobalMaxActiveXid);
>+		GlobalCurrentXid, GlobalMaxActiveXid);
> 	length += item_length;
> 	buf += item_length;
> 
>@@ -360,10 +368,10 @@ cifs_stats_read(char *buf, char **beginBuffer, off_t offset,
> 	list_for_each(tmp, &GlobalTreeConnectionList) {
> 		i++;
> 		tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
>-		item_length = sprintf(buf,"\n%d) %s",i, tcon->treeName);
>+		item_length = sprintf(buf, "\n%d) %s", i, tcon->treeName);
> 		buf += item_length;
> 		length += item_length;
>-		if(tcon->tidStatus == CifsNeedReconnect) {
>+		if (tcon->tidStatus == CifsNeedReconnect) {
> 			buf += sprintf(buf, "\tDISCONNECTED ");
> 			length += 14;
> 		}
>@@ -380,15 +388,15 @@ cifs_stats_read(char *buf, char **beginBuffer, off_t offset,
> 		item_length = sprintf(buf, "\nWrites: %d Bytes: %lld",
> 			atomic_read(&tcon->num_writes),
> 			(long long)(tcon->bytes_written));
>-                buf += item_length;
>-                length += item_length;
>-                item_length = sprintf(buf, 
>+		buf += item_length;
>+		length += item_length;
>+		item_length = sprintf(buf,
> 			"\nLocks: %d HardLinks: %d Symlinks: %d",
>-                        atomic_read(&tcon->num_locks),
>+			atomic_read(&tcon->num_locks),
> 			atomic_read(&tcon->num_hardlinks),
> 			atomic_read(&tcon->num_symlinks));
>-                buf += item_length;
>-                length += item_length;
>+		buf += item_length;
>+		length += item_length;
> 
> 		item_length = sprintf(buf, "\nOpens: %d Closes: %d Deletes: %d",
> 			atomic_read(&tcon->num_opens),
>@@ -415,12 +423,12 @@ cifs_stats_read(char *buf, char **beginBuffer, off_t offset,
> 	}
> 	read_unlock(&GlobalSMBSeslock);
> 
>-	buf += sprintf(buf,"\n");
>+	buf += sprintf(buf, "\n");
> 	length++;
> 
>-	if(offset + count >= length)
>+	if (offset + count >= length)
> 		*eof = 1;
>-	if(length < offset) {
>+	if (length < offset) {
> 		*eof = 1;
> 		return 0;
> 	} else {
>@@ -428,7 +436,7 @@ cifs_stats_read(char *buf, char **beginBuffer, off_t offset,
> 	}
> 	if (length > count)
> 		length = count;
>-		
>+
> 	return length;
> }
> #endif
>@@ -547,11 +555,11 @@ cifs_proc_clean(void)
> 	remove_proc_entry("MultiuserMount", proc_fs_cifs);
> 	remove_proc_entry("OplockEnabled", proc_fs_cifs);
> /*	remove_proc_entry("NTLMV2Enabled",proc_fs_cifs); */
>-	remove_proc_entry("SecurityFlags",proc_fs_cifs);
>-/*	remove_proc_entry("PacketSigningEnabled",proc_fs_cifs); */
>-	remove_proc_entry("LinuxExtensionsEnabled",proc_fs_cifs);
>-	remove_proc_entry("Experimental",proc_fs_cifs);
>-	remove_proc_entry("LookupCacheEnabled",proc_fs_cifs);
>+	remove_proc_entry("SecurityFlags", proc_fs_cifs);
>+/*	remove_proc_entry("PacketSigningEnabled", proc_fs_cifs); */
>+	remove_proc_entry("LinuxExtensionsEnabled", proc_fs_cifs);
>+	remove_proc_entry("Experimental", proc_fs_cifs);
>+	remove_proc_entry("LookupCacheEnabled", proc_fs_cifs);
> 	remove_proc_entry("cifs", proc_root_fs);
> }
> 
>@@ -590,7 +598,7 @@ cifsFYI_write(struct file *file, const char __user *buffer,
> 		cifsFYI = 0;
> 	else if (c == '1' || c == 'y' || c == 'Y')
> 		cifsFYI = 1;
>-	else if((c > '1') && (c <= '9'))
>+	else if ((c > '1') && (c <= '9'))
> 		cifsFYI = (int) (c - '0'); /* see cifs_debug.h for meanings */
> 
> 	return count;
>@@ -637,28 +645,28 @@ oplockEnabled_write(struct file *file, const char __user *buffer,
> 
> static int
> experimEnabled_read(char *page, char **start, off_t off,
>-                   int count, int *eof, void *data)
>+		    int count, int *eof, void *data)
> {
>-        int len;
>+	int len;
> 
>-        len = sprintf(page, "%d\n", experimEnabled);
>+	len = sprintf(page, "%d\n", experimEnabled);
> 
>-        len -= off;
>-        *start = page + off;
>+	len -= off;
>+	*start = page + off;
> 
>-        if (len > count)
>-                len = count;
>-        else
>-                *eof = 1;
>+	if (len > count)
>+		len = count;
>+	else
>+		*eof = 1;
> 
>-        if (len < 0)
>-                len = 0;
>+	if (len < 0)
>+		len = 0;
> 
>-        return len;
>+	return len;
> }
> static int
> experimEnabled_write(struct file *file, const char __user *buffer,
>-                    unsigned long count, void *data)
>+		     unsigned long count, void *data)
> {
> 	char c;
> 	int rc;
>@@ -678,46 +686,46 @@ experimEnabled_write(struct file *file, const char __user *buffer,
> 
> static int
> linuxExtensionsEnabled_read(char *page, char **start, off_t off,
>-                   int count, int *eof, void *data)
>+			    int count, int *eof, void *data)
> {
>-        int len;
>+	int len;
> 
>-        len = sprintf(page, "%d\n", linuxExtEnabled);
>-        len -= off;
>-        *start = page + off;
>+	len = sprintf(page, "%d\n", linuxExtEnabled);
>+	len -= off;
>+	*start = page + off;
> 
>-        if (len > count)
>-                len = count;
>-        else
>-                *eof = 1;
>+	if (len > count)
>+		len = count;
>+	else
>+		*eof = 1;
> 
>-        if (len < 0)
>-                len = 0;
>+	if (len < 0)
>+		len = 0;
> 
>-        return len;
>+	return len;
> }
> static int
> linuxExtensionsEnabled_write(struct file *file, const char __user *buffer,
>-                    unsigned long count, void *data)
>+			     unsigned long count, void *data)
> {
>-        char c;
>-        int rc;
>-
>-        rc = get_user(c, buffer);
>-        if (rc)
>-                return rc;
>-        if (c == '0' || c == 'n' || c == 'N')
>-                linuxExtEnabled = 0;
>-        else if (c == '1' || c == 'y' || c == 'Y')
>-                linuxExtEnabled = 1;
>-
>-        return count;
>+	char c;
>+	int rc;
>+
>+	rc = get_user(c, buffer);
>+	if (rc)
>+		return rc;
>+	if (c == '0' || c == 'n' || c == 'N')
>+		linuxExtEnabled = 0;
>+	else if (c == '1' || c == 'y' || c == 'Y')
>+		linuxExtEnabled = 1;
>+
>+	return count;
> }
> 
> 
> static int
> lookupFlag_read(char *page, char **start, off_t off,
>-		   int count, int *eof, void *data)
>+		int count, int *eof, void *data)
> {
> 	int len;
> 
>@@ -860,15 +868,15 @@ security_flags_write(struct file *file, const char __user *buffer,
> 	char flags_string[12];
> 	char c;
> 
>-	if((count < 1) || (count > 11))
>+	if ((count < 1) || (count > 11))
> 		return -EINVAL;
> 
> 	memset(flags_string, 0, 12);
> 
>-	if(copy_from_user(flags_string, buffer, count))
>+	if (copy_from_user(flags_string, buffer, count))
> 		return -EFAULT;
> 
>-	if(count < 3) {
>+	if (count < 3) {
> 		/* single char or single char followed by null */
> 		c = flags_string[0];
> 		if (c == '0' || c == 'n' || c == 'N')
>@@ -881,15 +889,15 @@ security_flags_write(struct file *file, const char __user *buffer,
> 
> 	flags = simple_strtoul(flags_string, NULL, 0);
> 
>-	cFYI(1,("sec flags 0x%x", flags));
>+	cFYI(1, ("sec flags 0x%x", flags));
> 
>-	if(flags <= 0)  {
>-		cERROR(1,("invalid security flags %s",flags_string));
>+	if (flags <= 0)  {
>+		cERROR(1, ("invalid security flags %s", flags_string));
> 		return -EINVAL;
> 	}
> 
>-	if(flags & ~CIFSSEC_MASK) {
>-		cERROR(1,("attempt to set unsupported security flags 0x%x",
>+	if (flags & ~CIFSSEC_MASK) {
>+		cERROR(1, ("attempt to set unsupported security flags 0x%x",
> 			flags & ~CIFSSEC_MASK));
> 		return -EINVAL;
> 	}
>@@ -898,9 +906,9 @@ security_flags_write(struct file *file, const char __user *buffer,
> 	if (extended_security & CIFSSEC_MUST_SIGN) {
> 		/* requiring signing implies signing is allowed */
> 		extended_security |= CIFSSEC_MAY_SIGN;
>-		cFYI(1,("packet signing now required"));
>+		cFYI(1, ("packet signing now required"));
> 	} else if ((extended_security & CIFSSEC_MAY_SIGN) == 0) {
>-		cFYI(1,("packet signing disabled"));
>+		cFYI(1, ("packet signing disabled"));
> 	}
> 	/* BB should we turn on MAY flags for other MUST options? */
> 	return count;
>diff --git a/fs/cifs/cifs_dfs_ref.c b/fs/cifs/cifs_dfs_ref.c
>new file mode 100644
>index 0000000..fc768f8
>--- /dev/null
>+++ b/fs/cifs/cifs_dfs_ref.c
>@@ -0,0 +1,451 @@
>+/*
>+ *  fs/cifs/cifs_dfs_ref.c
>+ *
>+ *   Copyright (C) International Business Machines  Corp., 2007
>+ *   Author(s): Steve French (sfrench@us.ibm.com)
>+ *              Igor Mammedov (niallain@gmail.com)
>+ *   Contains the CIFS DFS upcall routines
>+ *
>+ *   This library is free software; you can redistribute it and/or modify
>+ *   it under the terms of the GNU Lesser General Public License as published
>+ *   by the Free Software Foundation; either version 2.1 of the License, or
>+ *   (at your option) any later version.
>+ *
>+ *   This library is distributed in the hope that it will be useful,
>+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
>+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
>+ *   the GNU Lesser General Public License for more details.
>+ *
>+ *   You should have received a copy of the GNU Lesser General Public License
>+ *   along with this library; if not, write to the Free Software
>+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>+ */
>+
>+#include <linux/dcache.h>
>+#include <linux/mount.h>
>+#include <linux/namei.h>
>+#include <linux/vfs.h>
>+#include <linux/fs.h>
>+
>+#include "cifsfs.h"
>+#include "cifspdu.h"
>+#include "cifsglob.h"
>+#include "cifsproto.h"
>+#include "cifs_debug.h"
>+#include "cifs_fs_sb.h"
>+
>+#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)
>+#ifdef CONFIG_CIFS_EXPERIMENTAL
>+LIST_HEAD(cifs_dfs_automount_list);
>+
>+static void cifs_resolver_describe(const struct key *key, struct seq_file *m)
>+{
>+	cFYI(1, ("%s: key->description: %s", __FUNCTION__,  key->description ));
>+	seq_puts(m, key->description);
>+	seq_printf(m, ": %u", key->datalen);
>+}
>+
>+static int cifs_resolver_match(const struct key *key, const void *description)
>+{
>+	cFYI(1, ("%s: key->description: %s ; desc: %s ", __FUNCTION__,
>+		key->description, (char *)description ));
>+	return strcmp(key->description, description) == 0;
>+}
>+
>+static int cifs_resolver_instantiate(struct key *key, const void *data,
>+				     size_t datalen)
>+{
>+	char *ip = NULL;
>+	int rc;
>+	struct in_addr ip_addr;
>+
>+	/* convert dot ip addr to numeric form */
>+	/* BB Do we have to pass datalen? Are we guaranteed that the key
>+	 * is null terminated? */
>+	rc = cifs_inet_pton(AF_INET, (char *)data, &(ip_addr.s_addr));
>+	if (rc <= 0) {
>+		ip = kmalloc(datalen+1, GFP_KERNEL);
>+		if (ip == NULL) {
>+			return -ENOMEM;
>+		}
>+		strncpy( ip, (char *)data, datalen);
>+		ip[datalen] = 0;
>+
>+		cFYI(1, ("%s: failed to convert ip to binary: %s",
>+			__FUNCTION__, ip));
>+		kfree(ip);
>+		rc = -EINVAL;
>+		return rc;
>+	}
>+	rc = 0;
>+	key->payload.value = ip_addr.s_addr;
>+	return rc;
>+}
>+
>+struct key_type key_type_cifs_resolver =
>+{
>+	.name        = "cifs_resolver",
>+	.def_datalen = sizeof(struct in_addr),
>+	.describe    = cifs_resolver_describe,
>+	.instantiate = cifs_resolver_instantiate,
>+	.match       = cifs_resolver_match,
>+};
>+
>+
>+int
>+cifs_resolve_server_name_to_ip(const char *unc, struct in_addr *ip_addr) {
>+	int rc = -EAGAIN;
>+	struct key *rkey;
>+	char *name;
>+	int len;
>+
>+	if ((!ip_addr) || (!unc)) {
>+		return -EINVAL;
>+	}
>+
>+	/* search for server name delimiter */
>+	len = strlen( unc);
>+	if (len < 3) {
>+		cFYI(1, ("%s: unc is too short: %s",
>+			 __FUNCTION__, unc ));
>+		return -EINVAL;
>+	}
>+	len -= 2;
>+	name = memchr(unc+2, '\\', len);
>+	if (!name) {
>+		cFYI(1, ("%s: probably server name is whole unc: %s",
>+			 __FUNCTION__, unc ));
>+	} else {
>+		len = (name - unc) - 2/* leading // */;
>+	}
>+
>+	name = kmalloc( len+1, GFP_KERNEL);
>+	if (name == NULL) {
>+		rc = -ENOMEM;
>+		return rc;
>+	}
>+	memcpy( name, unc+2, len);
>+	name[len] = 0;
>+
>+	rkey = request_key(&key_type_cifs_resolver, name, "");
>+	if (!IS_ERR(rkey)) {
>+		ip_addr->s_addr = rkey->payload.value;
>+		cFYI(1, ("%s: resolved: %s to %u.%u.%u.%u", __FUNCTION__,
>+					rkey->description,
>+					NIPQUAD(ip_addr->s_addr)
>+			));
>+
>+		key_put(rkey);
>+		rc = 0;
>+	} else {
>+		cERROR(1, ("%s: unable to resolve: %s", __FUNCTION__, name));
>+	}
>+
>+	kfree(name);
>+	return rc;
>+}
>+
>+
>+char *
>+cifs_get_share_name(const char *node_name)
>+{
>+	int len;
>+	char *UNC;
>+	char *pSep;
>+
>+	len = strlen(node_name);
>+	UNC = kmalloc(len+2 /*for term null and additional \ if it's missed */,
>+			 GFP_KERNEL);
>+	if (!UNC) {
>+		return NULL;
>+	}
>+
>+	/* get share name and server name */
>+	if (node_name[1] != '\\'){
>+		UNC[0] = '\\';
>+		strncpy(UNC+1, node_name, len);
>+		len++;
>+		UNC[len] = 0;
>+	} else {
>+		strncpy(UNC, node_name, len);
>+		UNC[len] = 0;
>+	}
>+
>+	/* find server name end */
>+	pSep = memchr(UNC+2, '\\', len-2);
>+	if (!pSep) {
>+		cERROR(1, ("%s: no server name end in node name: %s",
>+			__FUNCTION__, node_name ));
>+		kfree(UNC);
>+		return NULL;
>+	}
>+
>+	/* find sharename end */
>+	pSep++;
>+	pSep = memchr(UNC+(pSep-UNC), '\\', len-(pSep-UNC));
>+	if (!pSep) {
>+		cERROR(1, ("%s:2 cant find share name in node name: %s",
>+			__FUNCTION__, node_name ));
>+		kfree(UNC);
>+		return NULL;
>+	}
>+	/* trim path up to sharename end
>+	 *          * now we have share name in UNC */
>+	*pSep = 0;
>+	len = pSep-UNC;
>+
>+	return UNC;
>+}
>+
>+
>+struct vfsmount *cifs_dfs_do_refmount(const struct vfsmount *mnt_parent,
>+				      struct dentry *dentry, char *ref_unc)
>+{
>+	int rc;
>+	struct cifs_sb_info *cifs_sb;
>+	struct sockaddr_in sin_server;
>+	struct vfsmount *mnt = ERR_PTR(-ENOENT);
>+	char *mountdata;
>+	int md_len;
>+	char *devname;
>+	char *tkn_e;
>+	char srvIP[16];
>+	char sep = ',';
>+	int off, noff;
>+
>+	cFYI(1, ("in %s", __FUNCTION__ ));
>+
>+	cifs_sb = CIFS_SB(dentry->d_inode->i_sb);
>+
>+	if ( cifs_sb->mountdata == NULL ) {
>+		return ERR_PTR(-EINVAL);
>+	}
>+
>+	devname = cifs_get_share_name(ref_unc);
>+	rc = cifs_resolve_server_name_to_ip( devname, &(sin_server.sin_addr));
>+	snprintf(srvIP, sizeof(srvIP), "%u.%u.%u.%u",
>+			NIPQUAD(sin_server.sin_addr));
>+	if (rc != 0) {
>+		if (devname) kfree(devname);
>+		cERROR(1, ("%s: failed to resolve server part of %s to IP",
>+			  __FUNCTION__, devname ));
>+		rc = -EINVAL;
>+		return ERR_PTR(rc);
>+	}
>+	srvIP[sizeof(srvIP)-1] = '\0';
>+	md_len = strlen(cifs_sb->mountdata) + sizeof(srvIP) +
>+			strlen(ref_unc) + 3;
>+	mountdata = kzalloc(md_len+1, GFP_KERNEL);
>+
>+	/* copy all options except unc,ip,prefixpath */
>+	off = 0;
>+	if (strncmp(cifs_sb->mountdata, "sep=", 4) == 0) {
>+			sep = cifs_sb->mountdata[4];
>+			strncpy(mountdata, cifs_sb->mountdata, 5);
>+			off += 5;
>+	}
>+	while ( (tkn_e = strchr(cifs_sb->mountdata+off, sep)) ) {
>+		noff = (tkn_e - (cifs_sb->mountdata+off)) + 1;
>+		if (strnicmp(cifs_sb->mountdata+off, "unc=", 4) == 0) {
>+			off += noff;
>+			continue;
>+		}
>+		if (strnicmp(cifs_sb->mountdata+off, "ip=", 3) == 0) {
>+			off += noff;
>+			continue;
>+		}
>+		if (strnicmp(cifs_sb->mountdata+off, "prefixpath=", 3) == 0) {
>+			off += noff;
>+			continue;
>+		}
>+		strncat(mountdata, cifs_sb->mountdata+off, noff);
>+		off += noff;
>+	}
>+	strcat(mountdata, cifs_sb->mountdata+off);
>+	mountdata[md_len] = '\0';
>+	strcat(mountdata, ", ip="); strcat(mountdata, srvIP);
>+	strcat(mountdata, ", unc="); strcat(mountdata, devname);
>+	/* find prefixpath */
>+	tkn_e = strchr(ref_unc+2, '\\');
>+	if ( tkn_e ) {
>+		tkn_e = strchr(tkn_e+1, '\\');
>+		if ( tkn_e ) {
>+			strcat(mountdata, ",prefixpath=");
>+			strcat(mountdata, tkn_e);
>+		}
>+	}
>+
>+	/*cFYI(1,("%s: old mountdata: %s", __FUNCTION__,cifs_sb->mountdata));*/
>+	/*cFYI(1, ("%s: new mountdata: %s", __FUNCTION__, mountdata ));*/
>+
>+	mnt = vfs_kern_mount(&cifs_fs_type, 0, devname, mountdata);
>+	if (devname)
>+		kfree(devname);
>+	if (mountdata)
>+		kfree(mountdata);
>+	cFYI(1, ("leaving %s", __FUNCTION__ ));
>+	return mnt;
>+}
>+
>+static char *build_full_dfs_path_from_dentry(struct dentry *dentry)
>+{
>+	char *full_path = NULL;
>+	char *search_path;
>+	char *tmp_path;
>+	size_t l_max_len;
>+	struct cifs_sb_info *cifs_sb;
>+
>+	if ( dentry->d_inode == NULL ) {
>+		return NULL;
>+	}
>+
>+	cifs_sb = CIFS_SB(dentry->d_inode->i_sb);
>+
>+	if ( cifs_sb->tcon == NULL ) {
>+		return NULL;
>+	}
>+
>+	search_path = build_path_from_dentry(dentry);
>+	if (search_path == NULL) {
>+		return NULL;
>+	}
>+
>+	if (cifs_sb->tcon->Flags & 0x2) {
>+		/* we should use full path name to correct working with DFS */
>+		l_max_len = strnlen(cifs_sb->tcon->treeName, MAX_TREE_SIZE + 1)
>+				     + strnlen(search_path, MAX_PATHCONF) + 1;
>+		tmp_path = kmalloc(l_max_len, GFP_KERNEL);
>+		if (tmp_path == NULL) {
>+			kfree(search_path);
>+			return NULL;
>+		}
>+		strncpy(tmp_path, cifs_sb->tcon->treeName, l_max_len);
>+		strcat(tmp_path, search_path);
>+		tmp_path[l_max_len-1] = 0;
>+		full_path = tmp_path;
>+		kfree(search_path);
>+	} else {
>+		full_path = search_path;
>+	}
>+	return full_path;
>+}
>+
>+static void *cifs_dfs_follow_mountpoint(struct dentry *dentry,
>+					struct nameidata *nd)
>+{
>+	DFS_INFO3_PARAM *referrals = NULL;
>+	unsigned int num_referrals = 0;
>+	struct cifs_sb_info *cifs_sb;
>+	struct cifsSesInfo *ses;
>+	char *full_path = NULL;
>+	int xid, i;
>+	int rc = 0;
>+	struct vfsmount *mnt = ERR_PTR(-ENOENT);
>+
>+	cFYI(1, ("in %s", __FUNCTION__ ));
>+	BUG_ON(IS_ROOT(dentry));
>+
>+	xid = GetXid();
>+
>+	dput(nd->dentry);
>+	nd->dentry = dget(dentry);
>+	if (d_mountpoint(nd->dentry)) {
>+		goto out_follow;
>+	}
>+
>+	if ( dentry->d_inode == NULL ) {
>+		rc = -EINVAL;
>+		goto out_err;
>+	}
>+
>+	cifs_sb = CIFS_SB(dentry->d_inode->i_sb);
>+	ses = cifs_sb->tcon->ses;
>+
>+	if ( !ses ) {
>+		rc = -EINVAL;
>+		goto out_err;
>+	}
>+
>+	full_path = build_full_dfs_path_from_dentry(dentry);
>+	if ( full_path == NULL ) {
>+		rc = -ENOMEM;
>+		goto out_err;
>+	}
>+
>+	rc = get_dfs_path(xid, ses , full_path, cifs_sb->local_nls,
>+			&num_referrals, &referrals,
>+			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
>+
>+	for (i = 0; i < num_referrals; i++) {
>+		cFYI(1, ("%s: ref path: %s", __FUNCTION__,
>+			 referrals[i].path_name));
>+		cFYI(1, ("%s: node path: %s", __FUNCTION__,
>+			 referrals[i].node_name ));
>+		cFYI(1, ("%s: fl: %hd, serv_type: %hd, ref_flags: %hd, "
>+			 "path_consumed: %hd", __FUNCTION__,
>+			 referrals[i].flags, referrals[i].server_type,
>+			 referrals[i].ref_flag, referrals[i].PathConsumed));
>+
>+		/* connect to storage node */
>+		if (referrals[i].flags & DFSREF_STORAGE_SERVER) {
>+			int len;
>+			len = strlen(referrals[i].node_name);
>+			if (len < 2) {
>+				cERROR(1, ("%s: Net Address path too short: %s",
>+					__FUNCTION__, referrals[i].node_name ));
>+				rc = -EINVAL;
>+				goto out_err;
>+			} else {
>+				mnt = cifs_dfs_do_refmount(nd->mnt,
>+						nd->dentry,
>+						referrals[i].node_name);
>+				cFYI(1, ("%s: cifs_dfs_do_refmount:%s , mnt:%p",
>+					 __FUNCTION__,
>+					 referrals[i].node_name, mnt));
>+				if ( !rc ) {
>+					/* have server so stop here & return */
>+					break;
>+				}
>+			}
>+		}
>+	}
>+
>+	rc = PTR_ERR(mnt);
>+	if (IS_ERR(mnt))
>+		goto out_err;
>+
>+	mntget(mnt);
>+	rc = do_add_mount(mnt, nd, nd->mnt->mnt_flags,
>+			  &cifs_dfs_automount_list);
>+	if (rc < 0) {
>+		mntput(mnt);
>+		if (rc == -EBUSY)
>+			goto out_follow;
>+		goto out_err;
>+	}
>+	mntput(nd->mnt);
>+	dput(nd->dentry);
>+	nd->mnt = mnt;
>+	nd->dentry = dget(mnt->mnt_root);
>+
>+out:
>+	FreeXid(xid);
>+	free_dfs_info_array(referrals, num_referrals);
>+	cFYI(1, ("leaving %s", __FUNCTION__ ));
>+	return ERR_PTR(rc);
>+out_err:
>+	if ( full_path ) kfree(full_path);
>+	path_release(nd);
>+	goto out;
>+out_follow:
>+	while (d_mountpoint(nd->dentry) && follow_down(&nd->mnt, &nd->dentry))
>+		;
>+	rc = 0;
>+	goto out;
>+}
>+
>+struct inode_operations cifs_dfs_referral_inode_operations = {
>+	.follow_link = cifs_dfs_follow_mountpoint,
>+};
>+#endif /* CONFIG_CIFS_EXPERIMENTAL */
>+#endif /* Kernel version 2.6.18 or higher */
>\ No newline at end of file
>diff --git a/fs/cifs/cifs_fs_sb.h b/fs/cifs/cifs_fs_sb.h
>index fd1e52e..34af556 100644
>--- a/fs/cifs/cifs_fs_sb.h
>+++ b/fs/cifs/cifs_fs_sb.h
>@@ -22,12 +22,14 @@
> #define CIFS_MOUNT_SET_UID      2 /* set current->euid in create etc. */
> #define CIFS_MOUNT_SERVER_INUM  4 /* inode numbers from uniqueid from server */
> #define CIFS_MOUNT_DIRECT_IO    8 /* do not write nor read through page cache */
>-#define CIFS_MOUNT_NO_XATTR  0x10 /* if set - disable xattr support */
>-#define CIFS_MOUNT_MAP_SPECIAL_CHR 0x20 /* remap illegal chars in filenames */
>-#define CIFS_MOUNT_POSIX_PATHS	0x40 /* Negotiate posix pathnames if possible. */
>-#define CIFS_MOUNT_UNX_EMUL	0x80 /* Network compat with SFUnix emulation */
>-#define CIFS_MOUNT_NO_BRL	0x100 /* No sending byte range locks to srv */
>-#define CIFS_MOUNT_CIFS_ACL	0x200 /* send ACL requests to non-POSIX srv */
>+#define CIFS_MOUNT_NO_XATTR     0x10  /* if set - disable xattr support       */
>+#define CIFS_MOUNT_MAP_SPECIAL_CHR 0x20 /* remap illegal chars in filenames   */
>+#define CIFS_MOUNT_POSIX_PATHS  0x40  /* Negotiate posix pathnames if possible*/
>+#define CIFS_MOUNT_UNX_EMUL     0x80  /* Network compat with SFUnix emulation */
>+#define CIFS_MOUNT_NO_BRL       0x100 /* No sending byte range locks to srv   */
>+#define CIFS_MOUNT_CIFS_ACL     0x200 /* send ACL requests to non-POSIX srv   */
>+#define CIFS_MOUNT_OVERR_UID    0x400 /* override uid returned from server    */
>+#define CIFS_MOUNT_OVERR_GID    0x800 /* override gid returned from server    */
> 
> struct cifs_sb_info {
> 	struct cifsTconInfo *tcon;	/* primary mount */
>@@ -41,6 +43,6 @@ struct cifs_sb_info {
> 	mode_t	mnt_dir_mode;
> 	int     mnt_cifs_flags;
> 	int	prepathlen;
>-	char *  prepath;
>+	char   *prepath;
> };
> #endif				/* _CIFS_FS_SB_H */
>diff --git a/fs/cifs/cifs_unicode.c b/fs/cifs/cifs_unicode.c
>index 793c4b9..b5903b8 100644
>--- a/fs/cifs/cifs_unicode.c
>+++ b/fs/cifs/cifs_unicode.c
>@@ -6,16 +6,16 @@
>  *
>  *   This program is free software;  you can redistribute it and/or modify
>  *   it under the terms of the GNU General Public License as published by
>- *   the Free Software Foundation; either version 2 of the License, or 
>+ *   the Free Software Foundation; either version 2 of the License, or
>  *   (at your option) any later version.
>- * 
>+ *
>  *   This program is distributed in the hope that it will be useful,
>  *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
>  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
>  *   the GNU General Public License for more details.
>  *
>  *   You should have received a copy of the GNU General Public License
>- *   along with this program;  if not, write to the Free Software 
>+ *   along with this program;  if not, write to the Free Software
>  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>  */
> #include <linux/fs.h>
>@@ -32,7 +32,7 @@
>  *
>  */
> int
>-cifs_strfromUCS_le(char *to, const __le16 * from,	
>+cifs_strfromUCS_le(char *to, const __le16 * from,
> 		   int len, const struct nls_table *codepage)
> {
> 	int i;
>@@ -66,7 +66,7 @@ cifs_strtoUCS(__le16 * to, const char *from, int len,
> {
> 	int charlen;
> 	int i;
>-	wchar_t * wchar_to = (wchar_t *)to; /* needed to quiet sparse */  
>+	wchar_t *wchar_to = (wchar_t *)to; /* needed to quiet sparse */
> 
> 	for (i = 0; len && *from; i++, from += charlen, len -= charlen) {
> 
>@@ -79,7 +79,7 @@ cifs_strtoUCS(__le16 * to, const char *from, int len,
> 			/* A question mark */
> 			to[i] = cpu_to_le16(0x003f);
> 			charlen = 1;
>-		} else 
>+		} else
> 			to[i] = cpu_to_le16(wchar_to[i]);
> 
> 	}
>diff --git a/fs/cifs/cifs_unicode.h b/fs/cifs/cifs_unicode.h
>index 1854df4..143f4e4 100644
>--- a/fs/cifs/cifs_unicode.h
>+++ b/fs/cifs/cifs_unicode.h
>@@ -5,20 +5,20 @@
>  *     Convert a unicode character to upper or lower case using
>  *     compressed tables.
>  *
>- *   Copyright (c) International Business Machines  Corp., 2000,2005555555555555555555555555555555555555555555555555555555
>+ *   Copyright (c) International Business Machines  Corp., 2000,2007
>  *
>  *   This program is free software;  you can redistribute it and/or modify
>  *   it under the terms of the GNU General Public License as published by
>- *   the Free Software Foundation; either version 2 of the License, or 
>+ *   the Free Software Foundation; either version 2 of the License, or
>  *   (at your option) any later version.
>- * 
>+ *
>  *   This program is distributed in the hope that it will be useful,
>  *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
>  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
>  *   the GNU General Public License for more details.
>  *
>  *   You should have received a copy of the GNU General Public License
>- *   along with this program;  if not, write to the Free Software 
>+ *   along with this program;  if not, write to the Free Software
>  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>  *
>  *
>@@ -58,15 +58,19 @@ extern signed char UniLowerTable[512];
> extern struct UniCaseRange UniLowerRange[];
> #endif				/* UNIUPR_NOLOWER */
> 
>-#ifdef __KERNEL__
> #ifndef __le16
>-int cifs_strfromUCS_le(char *, const __u16 *, int, const struct nls_table *);
>-int cifs_strtoUCS(__u16 *, const char *, int, const struct nls_table *);
>-#else
>+#define __le16 __u16
>+#define __le32 __u32
>+#define __le64 __u64
>+#define __be16 __u16
>+#define __be32 __u32
>+#define __be64 __u64
>+#endif
>+
>+#ifdef __KERNEL__
> int cifs_strfromUCS_le(char *, const __le16 *, int, const struct nls_table *);
> int cifs_strtoUCS(__le16 *, const char *, int, const struct nls_table *);
> #endif
>-#endif
> 
> /*
>  * UniStrcat:  Concatenate the second string to the first
>@@ -75,7 +79,7 @@ int cifs_strtoUCS(__le16 *, const char *, int, const struct nls_table *);
>  *     Address of the first string
>  */
> static inline wchar_t *
>-UniStrcat(wchar_t * ucs1, const wchar_t * ucs2)
>+UniStrcat(wchar_t *ucs1, const wchar_t *ucs2)
> {
> 	wchar_t *anchor = ucs1;	/* save a pointer to start of ucs1 */
> 
>@@ -93,7 +97,7 @@ UniStrcat(wchar_t * ucs1, const wchar_t * ucs2)
>  *     or NULL if the character is not in the string
>  */
> static inline wchar_t *
>-UniStrchr(const wchar_t * ucs, wchar_t uc)
>+UniStrchr(const wchar_t *ucs, wchar_t uc)
> {
> 	while ((*ucs != uc) && *ucs)
> 		ucs++;
>@@ -112,7 +116,7 @@ UniStrchr(const wchar_t * ucs, wchar_t uc)
>  *     > 0:  First string is greater than second
>  */
> static inline int
>-UniStrcmp(const wchar_t * ucs1, const wchar_t * ucs2)
>+UniStrcmp(const wchar_t *ucs1, const wchar_t *ucs2)
> {
> 	while ((*ucs1 == *ucs2) && *ucs1) {
> 		ucs1++;
>@@ -125,7 +129,7 @@ UniStrcmp(const wchar_t * ucs1, const wchar_t * ucs2)
>  * UniStrcpy:  Copy a string
>  */
> static inline wchar_t *
>-UniStrcpy(wchar_t * ucs1, const wchar_t * ucs2)
>+UniStrcpy(wchar_t *ucs1, const wchar_t *ucs2)
> {
> 	wchar_t *anchor = ucs1;	/* save the start of result string */
> 
>@@ -137,7 +141,7 @@ UniStrcpy(wchar_t * ucs1, const wchar_t * ucs2)
>  * UniStrlen:  Return the length of a string (in 16 bit Unicode chars not bytes)
>  */
> static inline size_t
>-UniStrlen(const wchar_t * ucs1)
>+UniStrlen(const wchar_t *ucs1)
> {
> 	int i = 0;
> 
>@@ -147,10 +151,11 @@ UniStrlen(const wchar_t * ucs1)
> }
> 
> /*
>- * UniStrnlen:  Return the length (in 16 bit Unicode chars not bytes) of a string (length limited)
>+ * UniStrnlen:  Return the length (in 16 bit Unicode chars not bytes) of a
>+ *		string (length limited)
>  */
> static inline size_t
>-UniStrnlen(const wchar_t * ucs1, int maxlen)
>+UniStrnlen(const wchar_t *ucs1, int maxlen)
> {
> 	int i = 0;
> 
>@@ -166,7 +171,7 @@ UniStrnlen(const wchar_t * ucs1, int maxlen)
>  * UniStrncat:  Concatenate length limited string
>  */
> static inline wchar_t *
>-UniStrncat(wchar_t * ucs1, const wchar_t * ucs2, size_t n)
>+UniStrncat(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
> {
> 	wchar_t *anchor = ucs1;	/* save pointer to string 1 */
> 
>@@ -184,7 +189,7 @@ UniStrncat(wchar_t * ucs1, const wchar_t * ucs2, size_t n)
>  * UniStrncmp:  Compare length limited string
>  */
> static inline int
>-UniStrncmp(const wchar_t * ucs1, const wchar_t * ucs2, size_t n)
>+UniStrncmp(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
> {
> 	if (!n)
> 		return 0;	/* Null strings are equal */
>@@ -199,7 +204,7 @@ UniStrncmp(const wchar_t * ucs1, const wchar_t * ucs2, size_t n)
>  * UniStrncmp_le:  Compare length limited string - native to little-endian
>  */
> static inline int
>-UniStrncmp_le(const wchar_t * ucs1, const wchar_t * ucs2, size_t n)
>+UniStrncmp_le(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
> {
> 	if (!n)
> 		return 0;	/* Null strings are equal */
>@@ -214,7 +219,7 @@ UniStrncmp_le(const wchar_t * ucs1, const wchar_t * ucs2, size_t n)
>  * UniStrncpy:  Copy length limited string with pad
>  */
> static inline wchar_t *
>-UniStrncpy(wchar_t * ucs1, const wchar_t * ucs2, size_t n)
>+UniStrncpy(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
> {
> 	wchar_t *anchor = ucs1;
> 
>@@ -231,7 +236,7 @@ UniStrncpy(wchar_t * ucs1, const wchar_t * ucs2, size_t n)
>  * UniStrncpy_le:  Copy length limited string with pad to little-endian
>  */
> static inline wchar_t *
>-UniStrncpy_le(wchar_t * ucs1, const wchar_t * ucs2, size_t n)
>+UniStrncpy_le(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
> {
> 	wchar_t *anchor = ucs1;
> 
>@@ -252,7 +257,7 @@ UniStrncpy_le(wchar_t * ucs1, const wchar_t * ucs2, size_t n)
>  *     NULL if no matching string is found
>  */
> static inline wchar_t *
>-UniStrstr(const wchar_t * ucs1, const wchar_t * ucs2)
>+UniStrstr(const wchar_t *ucs1, const wchar_t *ucs2)
> {
> 	const wchar_t *anchor1 = ucs1;
> 	const wchar_t *anchor2 = ucs2;
>@@ -302,7 +307,7 @@ UniToupper(register wchar_t uc)
>  * UniStrupr:  Upper case a unicode string
>  */
> static inline wchar_t *
>-UniStrupr(register wchar_t * upin)
>+UniStrupr(register wchar_t *upin)
> {
> 	register wchar_t *up;
> 
>@@ -343,7 +348,7 @@ UniTolower(wchar_t uc)
>  * UniStrlwr:  Lower case a unicode string
>  */
> static inline wchar_t *
>-UniStrlwr(register wchar_t * upin)
>+UniStrlwr(register wchar_t *upin)
> {
> 	register wchar_t *up;
> 
>diff --git a/fs/cifs/cifs_uniupr.h b/fs/cifs/cifs_uniupr.h
>index da2ad5b..18a9d97 100644
>--- a/fs/cifs/cifs_uniupr.h
>+++ b/fs/cifs/cifs_uniupr.h
>@@ -3,16 +3,16 @@
>  *
>  *   This program is free software;  you can redistribute it and/or modify
>  *   it under the terms of the GNU General Public License as published by
>- *   the Free Software Foundation; either version 2 of the License, or 
>+ *   the Free Software Foundation; either version 2 of the License, or
>  *   (at your option) any later version.
>- * 
>+ *
>  *   This program is distributed in the hope that it will be useful,
>  *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
>  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
>  *   the GNU General Public License for more details.
>  *
>  *   You should have received a copy of the GNU General Public License
>- *   along with this program;  if not, write to the Free Software 
>+ *   along with this program;  if not, write to the Free Software
>  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>  *
>  * uniupr.h - Unicode compressed case ranges
>@@ -53,7 +53,7 @@ signed char CifsUniUpperTable[512] = {
> 	0, -1, 0, -1, 0, -1, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0,	/* 1a0-1af */
> 	-1, 0, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0,	/* 1b0-1bf */
> 	0, 0, 0, 0, 0, -1, -2, 0, -1, -2, 0, -1, -2, 0, -1, 0,	/* 1c0-1cf */
>-	-1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, -79, 0, -1,	/* 1d0-1df */
>+	-1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, -79, 0, -1, /* 1d0-1df */
> 	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1e0-1ef */
> 	0, 0, -1, -2, 0, -1, 0, 0, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1f0-1ff */
> };
>diff --git a/fs/cifs/cifsacl.h b/fs/cifs/cifsacl.h
>index d0776ac..5eff35d 100644
>--- a/fs/cifs/cifsacl.h
>+++ b/fs/cifs/cifsacl.h
>@@ -31,8 +31,8 @@ struct cifs_sid {
> } __attribute__((packed));
> 
> /* everyone */
>-extern const struct cifs_sid sid_everyone;
>+/* extern const struct cifs_sid sid_everyone;*/
> /* group users */
>-extern const struct cifs_sid sid_user;
>+/* extern const struct cifs_sid sid_user;*/
> 
> #endif /* _CIFSACL_H */
>diff --git a/fs/cifs/cifsencrypt.c b/fs/cifs/cifsencrypt.c
>index fdeda51..3627229 100644
>--- a/fs/cifs/cifsencrypt.c
>+++ b/fs/cifs/cifsencrypt.c
>@@ -21,7 +21,7 @@
> 
> #include <linux/fs.h>
> #include "cifspdu.h"
>-#include "cifsglob.h" 
>+#include "cifsglob.h"
> #include "cifs_debug.h"
> #include "md5.h"
> #include "cifs_unicode.h"
>@@ -29,54 +29,57 @@
> #include <linux/ctype.h>
> #include <linux/random.h>
> 
>-/* Calculate and return the CIFS signature based on the mac key and the smb pdu */
>+/* Calculate and return the CIFS signature based on the mac key and SMB PDU */
> /* the 16 byte signature must be allocated by the caller  */
> /* Note we only use the 1st eight bytes */
>-/* Note that the smb header signature field on input contains the  
>+/* Note that the smb header signature field on input contains the
> 	sequence number before this function is called */
> 
> extern void mdfour(unsigned char *out, unsigned char *in, int n);
> extern void E_md4hash(const unsigned char *passwd, unsigned char *p16);
> extern void SMBencrypt(unsigned char *passwd, unsigned char *c8,
>-                       unsigned char *p24);
>-	
>-static int cifs_calculate_signature(const struct smb_hdr * cifs_pdu, 
>-				    const char * key, char * signature)
>+		       unsigned char *p24);
>+
>+static int cifs_calculate_signature(const struct smb_hdr *cifs_pdu,
>+				    const struct mac_key *key, char *signature)
> {
> 	struct	MD5Context context;
> 
>-	if((cifs_pdu == NULL) || (signature == NULL))
>+	if ((cifs_pdu == NULL) || (signature == NULL) || (key == NULL))
> 		return -EINVAL;
> 
> 	MD5Init(&context);
>-	MD5Update(&context,key,CIFS_SESS_KEY_SIZE+16);
>-	MD5Update(&context,cifs_pdu->Protocol,cifs_pdu->smb_buf_length);
>-	MD5Final(signature,&context);
>+	MD5Update(&context, (char *)&key->data, key->len);
>+	MD5Update(&context, cifs_pdu->Protocol, cifs_pdu->smb_buf_length);
>+
>+	MD5Final(signature, &context);
> 	return 0;
> }
> 
>-int cifs_sign_smb(struct smb_hdr * cifs_pdu, struct TCP_Server_Info * server,
>-	__u32 * pexpected_response_sequence_number)
>+int cifs_sign_smb(struct smb_hdr *cifs_pdu, struct TCP_Server_Info *server,
>+		  __u32 *pexpected_response_sequence_number)
> {
> 	int rc = 0;
> 	char smb_signature[20];
> 
>-	if((cifs_pdu == NULL) || (server == NULL))
>+	if ((cifs_pdu == NULL) || (server == NULL))
> 		return -EINVAL;
> 
>-	if((cifs_pdu->Flags2 & SMBFLG2_SECURITY_SIGNATURE) == 0) 
>+	if ((cifs_pdu->Flags2 & SMBFLG2_SECURITY_SIGNATURE) == 0)
> 		return rc;
> 
> 	spin_lock(&GlobalMid_Lock);
>-	cifs_pdu->Signature.Sequence.SequenceNumber = cpu_to_le32(server->sequence_number);
>+	cifs_pdu->Signature.Sequence.SequenceNumber =
>+			cpu_to_le32(server->sequence_number);
> 	cifs_pdu->Signature.Sequence.Reserved = 0;
>-	
>+
> 	*pexpected_response_sequence_number = server->sequence_number++;
> 	server->sequence_number++;
> 	spin_unlock(&GlobalMid_Lock);
> 
>-	rc = cifs_calculate_signature(cifs_pdu, server->mac_signing_key,smb_signature);
>-	if(rc)
>+	rc = cifs_calculate_signature(cifs_pdu, &server->mac_signing_key,
>+				      smb_signature);
>+	if (rc)
> 		memset(cifs_pdu->Signature.SecuritySignature, 0, 8);
> 	else
> 		memcpy(cifs_pdu->Signature.SecuritySignature, smb_signature, 8);
>@@ -84,115 +87,119 @@ int cifs_sign_smb(struct smb_hdr * cifs_pdu, struct TCP_Server_Info * server,
> 	return rc;
> }
> 
>-static int cifs_calc_signature2(const struct kvec * iov, int n_vec,
>-				const char * key, char * signature)
>+static int cifs_calc_signature2(const struct kvec *iov, int n_vec,
>+				const struct mac_key *key, char *signature)
> {
> 	struct  MD5Context context;
> 	int i;
> 
>-	if((iov == NULL) || (signature == NULL))
>+	if ((iov == NULL) || (signature == NULL) || (key == NULL))
> 		return -EINVAL;
> 
> 	MD5Init(&context);
>-	MD5Update(&context,key,CIFS_SESS_KEY_SIZE+16);
>-	for(i=0;i<n_vec;i++) {
>-		if(iov[i].iov_base == NULL) {
>-			cERROR(1,("null iovec entry"));
>+	MD5Update(&context, (char *)&key->data, key->len);
>+	for (i = 0; i < n_vec; i++) {
>+		if (iov[i].iov_base == NULL) {
>+			cERROR(1, ("null iovec entry"));
> 			return -EIO;
>-		} else if(iov[i].iov_len == 0)
>+		} else if (iov[i].iov_len == 0)
> 			break; /* bail out if we are sent nothing to sign */
>-		/* The first entry includes a length field (which does not get 
>+		/* The first entry includes a length field (which does not get
> 		   signed that occupies the first 4 bytes before the header */
>-		if(i==0) {
>+		if (i == 0) {
> 			if (iov[0].iov_len <= 8 ) /* cmd field at offset 9 */
> 				break; /* nothing to sign or corrupt header */
>-			MD5Update(&context,iov[0].iov_base+4, iov[0].iov_len-4);
>+			MD5Update(&context, iov[0].iov_base+4,
>+				  iov[0].iov_len-4);
> 		} else
>-			MD5Update(&context,iov[i].iov_base, iov[i].iov_len);
>+			MD5Update(&context, iov[i].iov_base, iov[i].iov_len);
> 	}
> 
>-	MD5Final(signature,&context);
>+	MD5Final(signature, &context);
> 
> 	return 0;
> }
> 
> 
>-int cifs_sign_smb2(struct kvec * iov, int n_vec, struct TCP_Server_Info *server,
>+int cifs_sign_smb2(struct kvec *iov, int n_vec, struct TCP_Server_Info *server,
> 		   __u32 * pexpected_response_sequence_number)
> {
> 	int rc = 0;
> 	char smb_signature[20];
>-	struct smb_hdr * cifs_pdu = iov[0].iov_base;
>+	struct smb_hdr *cifs_pdu = iov[0].iov_base;
> 
>-	if((cifs_pdu == NULL) || (server == NULL))
>+	if ((cifs_pdu == NULL) || (server == NULL))
> 		return -EINVAL;
> 
>-	if((cifs_pdu->Flags2 & SMBFLG2_SECURITY_SIGNATURE) == 0)
>+	if ((cifs_pdu->Flags2 & SMBFLG2_SECURITY_SIGNATURE) == 0)
> 		return rc;
> 
>-        spin_lock(&GlobalMid_Lock);
>-        cifs_pdu->Signature.Sequence.SequenceNumber = 
>+	spin_lock(&GlobalMid_Lock);
>+	cifs_pdu->Signature.Sequence.SequenceNumber =
> 				cpu_to_le32(server->sequence_number);
>-        cifs_pdu->Signature.Sequence.Reserved = 0;
>+	cifs_pdu->Signature.Sequence.Reserved = 0;
> 
>-        *pexpected_response_sequence_number = server->sequence_number++;
>-        server->sequence_number++;
>-        spin_unlock(&GlobalMid_Lock);
>+	*pexpected_response_sequence_number = server->sequence_number++;
>+	server->sequence_number++;
>+	spin_unlock(&GlobalMid_Lock);
> 
>-        rc = cifs_calc_signature2(iov, n_vec, server->mac_signing_key,
>+	rc = cifs_calc_signature2(iov, n_vec, &server->mac_signing_key,
> 				      smb_signature);
>-        if(rc)
>-                memset(cifs_pdu->Signature.SecuritySignature, 0, 8);
>-        else
>-                memcpy(cifs_pdu->Signature.SecuritySignature, smb_signature, 8);
>-
>-        return rc;
>+	if (rc)
>+		memset(cifs_pdu->Signature.SecuritySignature, 0, 8);
>+	else
>+		memcpy(cifs_pdu->Signature.SecuritySignature, smb_signature, 8);
> 
>+	return rc;
> }
> 
>-int cifs_verify_signature(struct smb_hdr * cifs_pdu, const char * mac_key,
>-	__u32 expected_sequence_number)
>+int cifs_verify_signature(struct smb_hdr *cifs_pdu,
>+			  const struct mac_key *mac_key,
>+			  __u32 expected_sequence_number)
> {
> 	unsigned int rc;
> 	char server_response_sig[8];
> 	char what_we_think_sig_should_be[20];
> 
>-	if((cifs_pdu == NULL) || (mac_key == NULL))
>+	if ((cifs_pdu == NULL) || (mac_key == NULL))
> 		return -EINVAL;
> 
> 	if (cifs_pdu->Command == SMB_COM_NEGOTIATE)
> 		return 0;
> 
> 	if (cifs_pdu->Command == SMB_COM_LOCKING_ANDX) {
>-		struct smb_com_lock_req * pSMB = (struct smb_com_lock_req *)cifs_pdu;
>-	    if(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE)
>+		struct smb_com_lock_req *pSMB =
>+			(struct smb_com_lock_req *)cifs_pdu;
>+	    if (pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE)
> 			return 0;
> 	}
> 
>-	/* BB what if signatures are supposed to be on for session but server does not
>-		send one? BB */
>-	
>+	/* BB what if signatures are supposed to be on for session but
>+	   server does not send one? BB */
>+
> 	/* Do not need to verify session setups with signature "BSRSPYL "  */
>-	if(memcmp(cifs_pdu->Signature.SecuritySignature,"BSRSPYL ",8)==0)
>-		cFYI(1,("dummy signature received for smb command 0x%x",cifs_pdu->Command));
>+	if (memcmp(cifs_pdu->Signature.SecuritySignature, "BSRSPYL ", 8) == 0)
>+		cFYI(1, ("dummy signature received for smb command 0x%x",
>+			cifs_pdu->Command));
> 
> 	/* save off the origiginal signature so we can modify the smb and check
> 		its signature against what the server sent */
>-	memcpy(server_response_sig,cifs_pdu->Signature.SecuritySignature,8);
>+	memcpy(server_response_sig, cifs_pdu->Signature.SecuritySignature, 8);
> 
>-	cifs_pdu->Signature.Sequence.SequenceNumber = cpu_to_le32(expected_sequence_number);
>+	cifs_pdu->Signature.Sequence.SequenceNumber =
>+					cpu_to_le32(expected_sequence_number);
> 	cifs_pdu->Signature.Sequence.Reserved = 0;
> 
> 	rc = cifs_calculate_signature(cifs_pdu, mac_key,
> 		what_we_think_sig_should_be);
> 
>-	if(rc)
>+	if (rc)
> 		return rc;
> 
>-	
>-/*	cifs_dump_mem("what we think it should be: ",what_we_think_sig_should_be,16); */
>+/*	cifs_dump_mem("what we think it should be: ",
>+		      what_we_think_sig_should_be, 16); */
> 
>-	if(memcmp(server_response_sig, what_we_think_sig_should_be, 8))
>+	if (memcmp(server_response_sig, what_we_think_sig_should_be, 8))
> 		return -EACCES;
> 	else
> 		return 0;
>@@ -200,89 +207,94 @@ int cifs_verify_signature(struct smb_hdr * cifs_pdu, const char * mac_key,
> }
> 
> /* We fill in key by putting in 40 byte array which was allocated by caller */
>-int cifs_calculate_mac_key(char * key, const char * rn, const char * password)
>+int cifs_calculate_mac_key(struct mac_key *key, const char *rn,
>+			   const char *password)
> {
> 	char temp_key[16];
> 	if ((key == NULL) || (rn == NULL))
> 		return -EINVAL;
> 
> 	E_md4hash(password, temp_key);
>-	mdfour(key,temp_key,16);
>-	memcpy(key+16,rn, CIFS_SESS_KEY_SIZE);
>+	mdfour(key->data.ntlm, temp_key, 16);
>+	memcpy(key->data.ntlm+16, rn, CIFS_SESS_KEY_SIZE);
>+	key->len = 40;
> 	return 0;
> }
> 
>-int CalcNTLMv2_partial_mac_key(struct cifsSesInfo * ses, 
>-				const struct nls_table * nls_info)
>+int CalcNTLMv2_partial_mac_key(struct cifsSesInfo *ses,
>+			       const struct nls_table *nls_info)
> {
> 	char temp_hash[16];
> 	struct HMACMD5Context ctx;
>-	char * ucase_buf;
>-	__le16 * unicode_buf;
>-	unsigned int i,user_name_len,dom_name_len;
>+	char *ucase_buf;
>+	__le16 *unicode_buf;
>+	unsigned int i, user_name_len, dom_name_len;
> 
>-	if(ses == NULL)
>+	if (ses == NULL)
> 		return -EINVAL;
> 
> 	E_md4hash(ses->password, temp_hash);
> 
> 	hmac_md5_init_limK_to_64(temp_hash, 16, &ctx);
> 	user_name_len = strlen(ses->userName);
>-	if(user_name_len > MAX_USERNAME_SIZE)
>+	if (user_name_len > MAX_USERNAME_SIZE)
> 		return -EINVAL;
>-	if(ses->domainName == NULL)
>+	if (ses->domainName == NULL)
> 		return -EINVAL; /* BB should we use CIFS_LINUX_DOM */
> 	dom_name_len = strlen(ses->domainName);
>-	if(dom_name_len > MAX_USERNAME_SIZE)
>+	if (dom_name_len > MAX_USERNAME_SIZE)
> 		return -EINVAL;
>-  
>+
> 	ucase_buf = kmalloc((MAX_USERNAME_SIZE+1), GFP_KERNEL);
>-	if(ucase_buf == NULL)
>+	if (ucase_buf == NULL)
> 		return -ENOMEM;
> 	unicode_buf = kmalloc((MAX_USERNAME_SIZE+1)*4, GFP_KERNEL);
>-	if(unicode_buf == NULL) {
>+	if (unicode_buf == NULL) {
> 		kfree(ucase_buf);
> 		return -ENOMEM;
> 	}
>-   
>-	for(i=0;i<user_name_len;i++)
>+
>+	for (i = 0; i < user_name_len; i++)
> 		ucase_buf[i] = nls_info->charset2upper[(int)ses->userName[i]];
> 	ucase_buf[i] = 0;
>-	user_name_len = cifs_strtoUCS(unicode_buf, ucase_buf, MAX_USERNAME_SIZE*2, nls_info);
>+	user_name_len = cifs_strtoUCS(unicode_buf, ucase_buf,
>+				      MAX_USERNAME_SIZE*2, nls_info);
> 	unicode_buf[user_name_len] = 0;
> 	user_name_len++;
> 
>-	for(i=0;i<dom_name_len;i++)
>+	for (i = 0; i < dom_name_len; i++)
> 		ucase_buf[i] = nls_info->charset2upper[(int)ses->domainName[i]];
> 	ucase_buf[i] = 0;
>-	dom_name_len = cifs_strtoUCS(unicode_buf+user_name_len, ucase_buf, MAX_USERNAME_SIZE*2, nls_info);
>+	dom_name_len = cifs_strtoUCS(unicode_buf+user_name_len, ucase_buf,
>+				     MAX_USERNAME_SIZE*2, nls_info);
> 
> 	unicode_buf[user_name_len + dom_name_len] = 0;
> 	hmac_md5_update((const unsigned char *) unicode_buf,
>-		(user_name_len+dom_name_len)*2,&ctx);
>+		(user_name_len+dom_name_len)*2, &ctx);
> 
>-	hmac_md5_final(ses->server->mac_signing_key,&ctx);
>+	hmac_md5_final(ses->server->ntlmv2_hash, &ctx);
> 	kfree(ucase_buf);
> 	kfree(unicode_buf);
> 	return 0;
> }
> 
> #ifdef CONFIG_CIFS_WEAK_PW_HASH
>-void calc_lanman_hash(struct cifsSesInfo * ses, char * lnm_session_key)
>+void calc_lanman_hash(struct cifsSesInfo *ses, char *lnm_session_key)
> {
> 	int i;
> 	char password_with_pad[CIFS_ENCPWD_SIZE];
> 
>-	if(ses->server == NULL)
>+	if (ses->server == NULL)
> 		return;
> 
> 	memset(password_with_pad, 0, CIFS_ENCPWD_SIZE);
>-	if(ses->password)
>+	if (ses->password)
> 		strncpy(password_with_pad, ses->password, CIFS_ENCPWD_SIZE);
> 
>-	if((ses->server->secMode & SECMODE_PW_ENCRYPT) == 0)
>-		if(extended_security & CIFSSEC_MAY_PLNTXT) {
>-			memcpy(lnm_session_key, password_with_pad, CIFS_ENCPWD_SIZE); 
>+	if ((ses->server->secMode & SECMODE_PW_ENCRYPT) == 0)
>+		if (extended_security & CIFSSEC_MAY_PLNTXT) {
>+			memcpy(lnm_session_key, password_with_pad,
>+				CIFS_ENCPWD_SIZE);
> 			return;
> 		}
> 
>@@ -297,7 +309,7 @@ void calc_lanman_hash(struct cifsSesInfo * ses, char * lnm_session_key)
> 	utf8 and other multibyte codepages each need their own strupper
> 	function since a byte at a time will ont work. */
> 
>-	for(i = 0; i < CIFS_ENCPWD_SIZE; i++) {
>+	for (i = 0; i < CIFS_ENCPWD_SIZE; i++) {
> 		password_with_pad[i] = toupper(password_with_pad[i]);
> 	}
> 
>@@ -307,19 +319,19 @@ void calc_lanman_hash(struct cifsSesInfo * ses, char * lnm_session_key)
> }
> #endif /* CIFS_WEAK_PW_HASH */
> 
>-static int calc_ntlmv2_hash(struct cifsSesInfo *ses, 
>-			    const struct nls_table * nls_cp)
>+static int calc_ntlmv2_hash(struct cifsSesInfo *ses,
>+			    const struct nls_table *nls_cp)
> {
> 	int rc = 0;
> 	int len;
> 	char nt_hash[16];
>-	struct HMACMD5Context * pctxt;
>-	wchar_t * user;
>-	wchar_t * domain;
>+	struct HMACMD5Context *pctxt;
>+	wchar_t *user;
>+	wchar_t *domain;
> 
> 	pctxt = kmalloc(sizeof(struct HMACMD5Context), GFP_KERNEL);
> 
>-	if(pctxt == NULL)
>+	if (pctxt == NULL)
> 		return -ENOMEM;
> 
> 	/* calculate md4 hash of password */
>@@ -331,41 +343,45 @@ static int calc_ntlmv2_hash(struct cifsSesInfo *ses,
> 	/* convert ses->userName to unicode and uppercase */
> 	len = strlen(ses->userName);
> 	user = kmalloc(2 + (len * 2), GFP_KERNEL);
>-	if(user == NULL)
>+	if (user == NULL)
> 		goto calc_exit_2;
> 	len = cifs_strtoUCS(user, ses->userName, len, nls_cp);
> 	UniStrupr(user);
> 	hmac_md5_update((char *)user, 2*len, pctxt);
> 
> 	/* convert ses->domainName to unicode and uppercase */
>-	if(ses->domainName) {
>+	if (ses->domainName) {
> 		len = strlen(ses->domainName);
> 
>-        	domain = kmalloc(2 + (len * 2), GFP_KERNEL);
>-		if(domain == NULL)
>+		domain = kmalloc(2 + (len * 2), GFP_KERNEL);
>+		if (domain == NULL)
> 			goto calc_exit_1;
> 		len = cifs_strtoUCS(domain, ses->domainName, len, nls_cp);
>-		UniStrupr(domain);
>+		/* the following line was removed since it didn't work well
>+		   with lower cased domain name that passed as an option.
>+		   Maybe converting the domain name earlier makes sense */
>+		/* UniStrupr(domain); */
> 
> 		hmac_md5_update((char *)domain, 2*len, pctxt);
>-	
>+
> 		kfree(domain);
> 	}
> calc_exit_1:
> 	kfree(user);
> calc_exit_2:
>-	/* BB FIXME what about bytes 24 through 40 of the signing key? 
>+	/* BB FIXME what about bytes 24 through 40 of the signing key?
> 	   compare with the NTLM example */
>-	hmac_md5_final(ses->server->mac_signing_key, pctxt);
>+	hmac_md5_final(ses->server->ntlmv2_hash, pctxt);
> 
> 	return rc;
> }
> 
>-void setup_ntlmv2_rsp(struct cifsSesInfo * ses, char * resp_buf, 
>-		      const struct nls_table * nls_cp)
>+void setup_ntlmv2_rsp(struct cifsSesInfo *ses, char *resp_buf,
>+		      const struct nls_table *nls_cp)
> {
> 	int rc;
>-	struct ntlmv2_resp * buf = (struct ntlmv2_resp *)resp_buf;
>+	struct ntlmv2_resp *buf = (struct ntlmv2_resp *)resp_buf;
>+	struct HMACMD5Context context;
> 
> 	buf->blob_signature = cpu_to_le32(0x00000101);
> 	buf->reserved = 0;
>@@ -379,21 +395,31 @@ void setup_ntlmv2_rsp(struct cifsSesInfo * ses, char * resp_buf,
> 
> 	/* calculate buf->ntlmv2_hash */
> 	rc = calc_ntlmv2_hash(ses, nls_cp);
>-	if(rc)
>-		cERROR(1,("could not get v2 hash rc %d",rc));
>+	if (rc)
>+		cERROR(1, ("could not get v2 hash rc %d", rc));
> 	CalcNTLMv2_response(ses, resp_buf);
>+
>+	/* now calculate the MAC key for NTLMv2 */
>+	hmac_md5_init_limK_to_64(ses->server->ntlmv2_hash, 16, &context);
>+	hmac_md5_update(resp_buf, 16, &context);
>+	hmac_md5_final(ses->server->mac_signing_key.data.ntlmv2.key, &context);
>+
>+	memcpy(&ses->server->mac_signing_key.data.ntlmv2.resp, resp_buf,
>+	       sizeof(struct ntlmv2_resp));
>+	ses->server->mac_signing_key.len = 16 + sizeof(struct ntlmv2_resp);
> }
> 
>-void CalcNTLMv2_response(const struct cifsSesInfo * ses, char * v2_session_response)
>+void CalcNTLMv2_response(const struct cifsSesInfo *ses,
>+			 char *v2_session_response)
> {
> 	struct HMACMD5Context context;
> 	/* rest of v2 struct already generated */
>-	memcpy(v2_session_response + 8, ses->server->cryptKey,8);
>-	hmac_md5_init_limK_to_64(ses->server->mac_signing_key, 16, &context);
>+	memcpy(v2_session_response + 8, ses->server->cryptKey, 8);
>+	hmac_md5_init_limK_to_64(ses->server->ntlmv2_hash, 16, &context);
> 
>-	hmac_md5_update(v2_session_response+8, 
>+	hmac_md5_update(v2_session_response+8,
> 			sizeof(struct ntlmv2_resp) - 8, &context);
> 
>-	hmac_md5_final(v2_session_response,&context);
>+	hmac_md5_final(v2_session_response, &context);
> /*	cifs_dump_mem("v2_sess_rsp: ", v2_session_response, 32); */
> }
>diff --git a/fs/cifs/cifsencrypt.h b/fs/cifs/cifsencrypt.h
>index 03e359b..152fa2d 100644
>--- a/fs/cifs/cifsencrypt.h
>+++ b/fs/cifs/cifsencrypt.h
>@@ -27,8 +27,6 @@ extern void mdfour(unsigned char *out, unsigned char *in, int n);
> /* smbdes.c */
> extern void E_P16(unsigned char *p14, unsigned char *p16);
> extern void E_P24(unsigned char *p21, unsigned char *c8, unsigned char *p24);
>-extern void D_P16(unsigned char *p14, unsigned char *in, unsigned char *out);
>-extern void E_old_pw_hash(unsigned char *, unsigned char *, unsigned char *);
> 
> 
> 
>diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
>index 153e118..ed8e77e 100644
>--- a/fs/cifs/cifsfs.c
>+++ b/fs/cifs/cifsfs.c
>@@ -33,6 +33,7 @@
> #include <linux/vfs.h>
> #include <linux/mempool.h>
> #include <linux/delay.h>
>+#include <linux/kthread.h>
> #include "cifsfs.h"
> #include "cifspdu.h"
> #define DECLARE_GLOBALS_HERE
>@@ -47,7 +48,7 @@
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,19)
> #include <linux/freezer.h>
> #endif /* 2.6.19 */
>-#define CIFS_MAGIC_NUMBER 0xFF534D42    /* the first four bytes of SMB PDUs */
>+#define CIFS_MAGIC_NUMBER 0xFF534D42	/* the first four bytes of SMB PDUs */
> 
> #ifdef CONFIG_CIFS_QUOTA
> static struct quotactl_ops cifs_quotactl_ops;
>@@ -68,31 +69,33 @@ unsigned int multiuser_mount = 0;
> unsigned int extended_security = CIFSSEC_DEF;
> /* unsigned int ntlmv2_support = 0; */
> unsigned int sign_CIFS_PDUs = 1;
>-extern struct task_struct * oplockThread; /* remove sparse warning */
>-struct task_struct * oplockThread = NULL;
>+extern struct task_struct *oplockThread; /* remove sparse warning */
>+struct task_struct *oplockThread = NULL;
> /* extern struct task_struct * dnotifyThread; remove sparse warning */
>-static struct task_struct * dnotifyThread = NULL;
>+static struct task_struct *dnotifyThread = NULL;
>+static const struct super_operations cifs_super_ops;
> unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
> module_param(CIFSMaxBufSize, int, 0);
>-MODULE_PARM_DESC(CIFSMaxBufSize,"Network buffer size (not including header). Default: 16384 Range: 8192 to 130048");
>+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;
> module_param(cifs_min_rcv, int, 0);
>-MODULE_PARM_DESC(cifs_min_rcv,"Network buffers in pool. Default: 4 Range: 1 to 64");
>+MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
>+				"1 to 64");
> unsigned int cifs_min_small = 30;
> module_param(cifs_min_small, int, 0);
>-MODULE_PARM_DESC(cifs_min_small,"Small network buffers in pool. Default: 30 Range: 2 to 256");
>+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;
> module_param(cifs_max_pending, int, 0);
>-MODULE_PARM_DESC(cifs_max_pending,"Simultaneous requests to server. Default: 50 Range: 2 to 256");
>-
>-static DECLARE_COMPLETION(cifs_oplock_exited);
>-static DECLARE_COMPLETION(cifs_dnotify_exited);
>+MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
>+				   "Default: 50 Range: 2 to 256");
> 
> extern mempool_t *cifs_sm_req_poolp;
> extern mempool_t *cifs_req_poolp;
> extern mempool_t *cifs_mid_poolp;
> 
>-extern kmem_cache_t *cifs_oplock_cachep;
>+extern struct kmem_cache *cifs_oplock_cachep;
> 
> static int
> cifs_read_super(struct super_block *sb, void *data,
>@@ -101,12 +104,12 @@ cifs_read_super(struct super_block *sb, void *data,
> 	struct inode *inode;
> 	struct cifs_sb_info *cifs_sb;
> 	int rc = 0;
>-	
>+
> 	/* BB should we make this contingent on mount parm? */
> 	sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
>-	sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info),GFP_KERNEL);
>+	sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
> 	cifs_sb = CIFS_SB(sb);
>-	if(cifs_sb == NULL)
>+	if (cifs_sb == NULL)
> 		return -ENOMEM;
> 
> 	rc = cifs_mount(sb, cifs_sb, data, devname);
>@@ -120,12 +123,9 @@ cifs_read_super(struct super_block *sb, void *data,
> 
> 	sb->s_magic = CIFS_MAGIC_NUMBER;
> 	sb->s_op = &cifs_super_ops;
>-#ifdef CONFIG_CIFS_EXPERIMENTAL
>-	if(experimEnabled != 0)
>-		sb->s_export_op = &cifs_export_ops;
>-#endif /* EXPERIMENTAL */	
>-/*	if(cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
>-	    sb->s_blocksize = cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
>+/*	if (cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
>+	    sb->s_blocksize =
>+		cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
> #ifdef CONFIG_CIFS_QUOTA
> 	sb->s_qcop = &cifs_quotactl_ops;
> #endif
>@@ -145,6 +145,13 @@ cifs_read_super(struct super_block *sb, void *data,
> 		goto out_no_root;
> 	}
> 
>+#ifdef CONFIG_CIFS_EXPERIMENTAL
>+	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
>+		cFYI(1, ("export ops supported"));
>+		sb->s_export_op = &cifs_export_ops;
>+	}
>+#endif /* EXPERIMENTAL */
>+
> 	return 0;
> 
> out_no_root:
>@@ -153,9 +160,9 @@ out_no_root:
> 		iput(inode);
> 
> out_mount_failed:
>-	if(cifs_sb) {
>-		if(cifs_sb->local_nls)
>-			unload_nls(cifs_sb->local_nls);	
>+	if (cifs_sb) {
>+		if (cifs_sb->local_nls)
>+			unload_nls(cifs_sb->local_nls);
> 		kfree(cifs_sb);
> 	}
> 	return rc;
>@@ -169,11 +176,11 @@ cifs_put_super(struct super_block *sb)
> 
> 	cFYI(1, ("In cifs_put_super"));
> 	cifs_sb = CIFS_SB(sb);
>-	if(cifs_sb == NULL) {
>-		cFYI(1,("Empty cifs superblock info passed to unmount"));
>+	if (cifs_sb == NULL) {
>+		cFYI(1, ("Empty cifs superblock info passed to unmount"));
> 		return;
> 	}
>-	rc = cifs_umount(sb, cifs_sb); 
>+	rc = cifs_umount(sb, cifs_sb);
> 	if (rc) {
> 		cERROR(1, ("cifs_umount failed with return code %d", rc));
> 	}
>@@ -182,7 +189,7 @@ cifs_put_super(struct super_block *sb)
> 	return;
> }
> 
>-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 16)
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 15)
> void * kzalloc(size_t size, unsigned flgs)
> {
> 	void * buf;
>@@ -199,11 +206,18 @@ cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
> {
> 	struct super_block *sb = dentry->d_sb;
> #else
>+static inline mempool_t *
>+mempool_create_slab_pool(int min_nr, struct kmem_cache *kc)
>+{
>+        return mempool_create(min_nr, mempool_alloc_slab, mempool_free_slab,
>+                              (void *) kc);
>+}
>+
> static int
> cifs_statfs(struct super_block *sb, struct kstatfs *buf)
> {
> #endif	
>-	int xid; 
>+	int xid;
> 	int rc = -EOPNOTSUPP;
> 	struct cifs_sb_info *cifs_sb;
> 	struct cifsTconInfo *pTcon;
>@@ -216,7 +230,7 @@ cifs_statfs(struct super_block *sb, struct kstatfs *buf)
> 	buf->f_type = CIFS_MAGIC_NUMBER;
> 
> 	/* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */
>-	buf->f_namelen = PATH_MAX; /* PATH_MAX may be too long - it would 
>+	buf->f_namelen = PATH_MAX; /* PATH_MAX may be too long - it would
> 				      presumably be total path, but note
> 				      that some servers (includinng Samba 3)
> 				      have a shorter maximum path */
>@@ -231,17 +245,16 @@ cifs_statfs(struct super_block *sb, struct kstatfs *buf)
> 
>     /* Only need to call the old QFSInfo if failed
>     on newer one */
>-    if(rc)
>-	if(pTcon->ses->capabilities & CAP_NT_SMBS)
>+    if (rc)
>+	if (pTcon->ses->capabilities & CAP_NT_SMBS)
> 		rc = CIFSSMBQFSInfo(xid, pTcon, buf); /* not supported by OS2 */
> 
> 	/* Some old Windows servers also do not support level 103, retry with
> 	   older level one if old server failed the previous call or we
> 	   bypassed it because we detected that this was an older LANMAN sess */
>-	if(rc)
>+	if (rc)
> 		rc = SMBOldQFSInfo(xid, pTcon, buf);
>-	/*     
>-	   int f_type;
>+	/* int f_type;
> 	   __fsid_t f_fsid;
> 	   int f_namelen;  */
> 	/* BB get from info in tcon struct at mount time call to QFSAttrInfo */
>@@ -250,30 +263,30 @@ cifs_statfs(struct super_block *sb, struct kstatfs *buf)
> 				   longer available? */
> }
> 
>-static int cifs_permission(struct inode * inode, int mask, struct nameidata *nd)
>+static int cifs_permission(struct inode *inode, int mask, struct nameidata *nd)
> {
> 	struct cifs_sb_info *cifs_sb;
> 
> 	cifs_sb = CIFS_SB(inode->i_sb);
> 
>-	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
>+	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
> 		return 0;
>-	} else /* file mode might have been restricted at mount time 
>-		on the client (above and beyond ACL on servers) for  
>+	else /* file mode might have been restricted at mount time
>+		on the client (above and beyond ACL on servers) for
> 		servers which do not support setting and viewing mode bits,
> 		so allowing client to check permissions is useful */
> #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) 
> 		return vfs_permission(inode, mask);
> #else
> 		return generic_permission(inode, mask, NULL);
>-#endif /* LINUX version */
>+#endif
> }
> 
>-static kmem_cache_t *cifs_inode_cachep;
>-static kmem_cache_t *cifs_req_cachep;
>-static kmem_cache_t *cifs_mid_cachep;
>-kmem_cache_t *cifs_oplock_cachep;
>-static kmem_cache_t *cifs_sm_req_cachep;
>+static struct kmem_cache *cifs_inode_cachep;
>+static struct kmem_cache *cifs_req_cachep;
>+static struct kmem_cache *cifs_mid_cachep;
>+struct kmem_cache *cifs_oplock_cachep;
>+static struct kmem_cache *cifs_sm_req_cachep;
> mempool_t *cifs_sm_req_poolp;
> mempool_t *cifs_req_poolp;
> mempool_t *cifs_mid_poolp;
>@@ -282,7 +295,7 @@ static struct inode *
> cifs_alloc_inode(struct super_block *sb)
> {
> 	struct cifsInodeInfo *cifs_inode;
>-	cifs_inode = kmem_cache_alloc(cifs_inode_cachep, SLAB_KERNEL);
>+	cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
> 	if (!cifs_inode)
> 		return NULL;
> 	cifs_inode->cifsAttrs = 0x20;	/* default */
>@@ -293,8 +306,11 @@ cifs_alloc_inode(struct super_block *sb)
> 	file data or metadata */
> 	cifs_inode->clientCanCacheRead = FALSE;
> 	cifs_inode->clientCanCacheAll = FALSE;
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
>+	cifs_inode->vfs_inode.i_blksize = CIFS_MAX_MSGSIZE;
>+#endif
> 	cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
>-	
>+
> 	/* Can not set i_flags here - they get immediately overwritten
> 	   to zero by the VFS */
> /*	cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
>@@ -328,59 +344,67 @@ cifs_show_options(struct seq_file *s, struct vfsmount *m)
> 				if (cifs_sb->tcon->ses->userName)
> 					seq_printf(s, ",username=%s",
> 					   cifs_sb->tcon->ses->userName);
>-				if(cifs_sb->tcon->ses->domainName)
>+				if (cifs_sb->tcon->ses->domainName)
> 					seq_printf(s, ",domain=%s",
> 					   cifs_sb->tcon->ses->domainName);
> 			}
> 		}
>-		seq_printf(s, ",rsize=%d",cifs_sb->rsize);
>-		seq_printf(s, ",wsize=%d",cifs_sb->wsize);
>+		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
>+			seq_printf(s, ",posixpaths");
>+		if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) ||
>+		   !(cifs_sb->tcon->unix_ext))
>+			seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
>+		if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) ||
>+		   !(cifs_sb->tcon->unix_ext))
>+			seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
>+		seq_printf(s, ",rsize=%d", cifs_sb->rsize);
>+		seq_printf(s, ",wsize=%d", cifs_sb->wsize);
> 	}
> 	return 0;
> }
> 
> #ifdef CONFIG_CIFS_QUOTA
>-int cifs_xquota_set(struct super_block * sb, int quota_type, qid_t qid,
>-		struct fs_disk_quota * pdquota)
>+int cifs_xquota_set(struct super_block *sb, int quota_type, qid_t qid,
>+		struct fs_disk_quota *pdquota)
> {
> 	int xid;
> 	int rc = 0;
> 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
> 	struct cifsTconInfo *pTcon;
>-	
>-	if(cifs_sb)
>+
>+	if (cifs_sb)
> 		pTcon = cifs_sb->tcon;
> 	else
> 		return -EIO;
> 
> 
> 	xid = GetXid();
>-	if(pTcon) {
>-		cFYI(1,("set type: 0x%x id: %d",quota_type,qid));		
>+	if (pTcon) {
>+		cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
> 	} else {
>-		return -EIO;
>+		rc = -EIO;
> 	}
> 
> 	FreeXid(xid);
> 	return rc;
> }
> 
>-int cifs_xquota_get(struct super_block * sb, int quota_type, qid_t qid,
>-                struct fs_disk_quota * pdquota)
>+int cifs_xquota_get(struct super_block *sb, int quota_type, qid_t qid,
>+		    struct fs_disk_quota *pdquota)
> {
> 	int xid;
> 	int rc = 0;
> 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
> 	struct cifsTconInfo *pTcon;
> 
>-	if(cifs_sb)
>+	if (cifs_sb)
> 		pTcon = cifs_sb->tcon;
> 	else
> 		return -EIO;
> 
> 	xid = GetXid();
>-	if(pTcon) {
>-                cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
>+	if (pTcon) {
>+		cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
> 	} else {
> 		rc = -EIO;
> 	}
>@@ -389,21 +413,21 @@ int cifs_xquota_get(struct super_block * sb, int quota_type, qid_t qid,
> 	return rc;
> }
> 
>-int cifs_xstate_set(struct super_block * sb, unsigned int flags, int operation)
>+int cifs_xstate_set(struct super_block *sb, unsigned int flags, int operation)
> {
>-	int xid; 
>+	int xid;
> 	int rc = 0;
> 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
> 	struct cifsTconInfo *pTcon;
> 
>-	if(cifs_sb)
>+	if (cifs_sb)
> 		pTcon = cifs_sb->tcon;
> 	else
> 		return -EIO;
> 
> 	xid = GetXid();
>-	if(pTcon) {
>-                cFYI(1,("flags: 0x%x operation: 0x%x",flags,operation));
>+	if (pTcon) {
>+		cFYI(1, ("flags: 0x%x operation: 0x%x", flags, operation));
> 	} else {
> 		rc = -EIO;
> 	}
>@@ -412,21 +436,21 @@ int cifs_xstate_set(struct super_block * sb, unsigned int flags, int operation)
> 	return rc;
> }
> 
>-int cifs_xstate_get(struct super_block * sb, struct fs_quota_stat *qstats)
>+int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
> {
> 	int xid;
> 	int rc = 0;
> 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
> 	struct cifsTconInfo *pTcon;
> 
>-	if(cifs_sb) {
>+	if (cifs_sb) {
> 		pTcon = cifs_sb->tcon;
> 	} else {
> 		return -EIO;
> 	}
> 	xid = GetXid();
>-	if(pTcon) {
>-		cFYI(1,("pqstats %p",qstats));		
>+	if (pTcon) {
>+		cFYI(1, ("pqstats %p", qstats));
> 	} else {
> 		rc = -EIO;
> 	}
>@@ -444,13 +468,13 @@ static struct quotactl_ops cifs_quotactl_ops = {
> #endif
> 
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 16)
>-static void cifs_umount_begin(struct vfsmount * vfsmnt, int flags)
>+static void cifs_umount_begin(struct vfsmount *vfsmnt, int flags)
> #else
> static void cifs_umount_begin(struct super_block * sblock)
> #endif
> {
> 	struct cifs_sb_info *cifs_sb;
>-	struct cifsTconInfo * tcon;
>+	struct cifsTconInfo *tcon;
> 
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 16)
> 	if (!(flags & MNT_FORCE))
>@@ -459,11 +483,11 @@ static void cifs_umount_begin(struct super_block * sblock)
> #else
> 	cifs_sb = CIFS_SB(sblock);
> #endif
>-	if(cifs_sb == NULL)
>+	if (cifs_sb == NULL)
> 		return;
> 
> 	tcon = cifs_sb->tcon;
>-	if(tcon == NULL)
>+	if (tcon == NULL)
> 		return;
> 	down(&tcon->tconSem);
> 	if (atomic_read(&tcon->useCount) == 1)
>@@ -472,9 +496,8 @@ static void cifs_umount_begin(struct super_block * sblock)
> 
> 	/* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
> 	/* cancel_notify_requests(tcon); */
>-	if(tcon->ses && tcon->ses->server)
>-	{
>-		cFYI(1,("wake up tasks now - umount begin not complete"));
>+	if (tcon->ses && tcon->ses->server) {
>+		cFYI(1, ("wake up tasks now - umount begin not complete"));
> 		wake_up_all(&tcon->ses->server->request_q);
> 		wake_up_all(&tcon->ses->server->response_q);
> 		msleep(1); /* yield */
>@@ -487,27 +510,46 @@ static void cifs_umount_begin(struct super_block * sblock)
> 	return;
> }
> 
>+#ifdef CONFIG_CIFS_STATS2
>+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)
>+static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
>+{
>+	/* BB FIXME */
>+	return 0;
>+}
>+#endif
>+#endif
>+
> static int cifs_remount(struct super_block *sb, int *flags, char *data)
> {
> 	*flags |= MS_NODIRATIME;
> 	return 0;
> }
> 
>-struct super_operations cifs_super_ops = {
>+static const struct super_operations cifs_super_ops = {
> 	.read_inode = cifs_read_inode,
> 	.put_super = cifs_put_super,
> 	.statfs = cifs_statfs,
> 	.alloc_inode = cifs_alloc_inode,
> 	.destroy_inode = cifs_destroy_inode,
>-/*	.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
>-   us with the same number of releases (closes) as opens */
>+/*	.drop_inode	    = generic_delete_inode,
>+	.delete_inode	= cifs_delete_inode,  */  /* Do not need above two
>+	functions unless later we add lazy close of inodes or unless the
>+	kernel forgets to call us with the same number of releases (closes)
>+	as opens */
> 	.show_options = cifs_show_options,
> 	.umount_begin   = cifs_umount_begin,
> 	.remount_fs = cifs_remount,
>+#ifdef CONFIG_CIFS_STATS2
>+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)
>+	.show_stats = cifs_show_stats,
>+#endif
>+#endif
> };
> 
>+#ifndef MS_SILENT
>+#define MS_SILENT MS_VERBOSE
>+#endif
> 
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)
> static int
>@@ -533,7 +575,7 @@ cifs_get_sb(struct file_system_type *fs_type,
> 
> 	sb->s_flags = flags;
> 
>-	rc = cifs_read_super(sb, data, dev_name, flags & MS_VERBOSE ? 1 : 0);
>+	rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
> 	if (rc) {
> 		up_write(&sb->s_umount);
> 		deactivate_super(sb);
>@@ -541,26 +583,25 @@ cifs_get_sb(struct file_system_type *fs_type,
> 		return rc;
> #else		
> 		return ERR_PTR(rc);
>-#endif		
>+#endif
> 	}
> 	sb->s_flags |= MS_ACTIVE;
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)
> 	return simple_set_mnt(mnt, sb);
>-#else	
>+#else
> 	return sb;
> #endif
> }
> 
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 18)
> static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
>-                                   unsigned long nr_segs, loff_t pos)
>+				   unsigned long nr_segs, loff_t pos)
> {
>-        struct inode *inode = iocb->ki_filp->f_dentry->d_inode;
>-        ssize_t written;
>+	struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
>+	ssize_t written;
> 
>-        written = generic_file_aio_write(iocb, iov, nr_segs, pos);
>+	written = generic_file_aio_write(iocb, iov, nr_segs, pos);
> #else
>-
> static ssize_t cifs_file_writev(struct file *file, const struct iovec *iov,
> 				unsigned long nr_segs, loff_t *ppos)
> {
>@@ -593,11 +634,10 @@ static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
> 		int retval;
> 
> 		/* some applications poll for the file length in this strange
>-                  way so we must seek to end on non-oplocked files by
>-                  setting the revalidate time to zero */
>+		   way so we must seek to end on non-oplocked files by
>+		   setting the revalidate time to zero */
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 19)
>-		if(file->f_path.dentry->d_inode)                
>-			CIFS_I(file->f_path.dentry->d_inode)->time = 0;
>+		CIFS_I(file->f_path.dentry->d_inode)->time = 0;
> 
> 		retval = cifs_revalidate(file->f_path.dentry);
> #else
>@@ -618,7 +658,7 @@ static struct file_system_type cifs_fs_type = {
> 	.kill_sb = kill_anon_super,
> 	/*  .fs_flags */
> };
>-struct inode_operations cifs_dir_inode_ops = {
>+const struct inode_operations cifs_dir_inode_ops = {
> 	.create = cifs_create,
> 	.lookup = cifs_lookup,
> 	.getattr = cifs_getattr,
>@@ -640,7 +680,7 @@ struct inode_operations cifs_dir_inode_ops = {
> #endif
> };
> 
>-struct inode_operations cifs_file_inode_ops = {
>+const struct inode_operations cifs_file_inode_ops = {
> /*	revalidate:cifs_revalidate, */
> 	.setattr = cifs_setattr,
> 	.getattr = cifs_getattr, /* do we need this anymore? */
>@@ -651,10 +691,10 @@ struct inode_operations cifs_file_inode_ops = {
> 	.getxattr = cifs_getxattr,
> 	.listxattr = cifs_listxattr,
> 	.removexattr = cifs_removexattr,
>-#endif 
>+#endif
> };
> 
>-struct inode_operations cifs_symlink_inode_ops = {
>+const struct inode_operations cifs_symlink_inode_ops = {
> #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,9)
> 	.readlink = cifs_readlink,
> #else
>@@ -671,7 +711,7 @@ struct inode_operations cifs_symlink_inode_ops = {
> 	.getxattr = cifs_getxattr,
> 	.listxattr = cifs_listxattr,
> 	.removexattr = cifs_removexattr,
>-#endif 
>+#endif
> };
> 
> const struct file_operations cifs_file_ops = {
>@@ -689,7 +729,11 @@ const struct file_operations cifs_file_ops = {
> 	.fsync = cifs_fsync,
> 	.flush = cifs_flush,
> 	.mmap  = cifs_file_mmap,
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
> 	.sendfile = generic_file_sendfile,
>+#else
>+	.splice_read = generic_file_splice_read,
>+#endif
> 	.llseek = cifs_llseek,
> #ifdef CONFIG_CIFS_POSIX
> 	.ioctl	= cifs_ioctl,
>@@ -701,7 +745,7 @@ const struct file_operations cifs_file_ops = {
> };
> 
> const struct file_operations cifs_file_direct_ops = {
>-	/* no mmap, no aio, no readv - 
>+	/* no mmap, no aio, no readv -
> 	   BB reevaluate whether they can be done with directio, no cache */
> 	.read = cifs_user_read,
> 	.write = cifs_user_write,
>@@ -710,7 +754,11 @@ const struct file_operations cifs_file_direct_ops = {
> 	.lock = cifs_lock,
> 	.fsync = cifs_fsync,
> 	.flush = cifs_flush,
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
> 	.sendfile = generic_file_sendfile, /* BB removeme BB */
>+#else
>+	.splice_read = generic_file_splice_read,
>+#endif
> #ifdef CONFIG_CIFS_POSIX
> 	.ioctl  = cifs_ioctl,
> #endif /* CONFIG_CIFS_POSIX */
>@@ -719,7 +767,6 @@ const struct file_operations cifs_file_direct_ops = {
> 	.dir_notify = cifs_dir_notify,
> #endif /* CONFIG_CIFS_EXPERIMENTAL */
> };
>-
> const struct file_operations cifs_file_nobrl_ops = {
> 	.read = do_sync_read,
> 	.write = do_sync_write,
>@@ -734,7 +781,11 @@ const struct file_operations cifs_file_nobrl_ops = {
> 	.fsync = cifs_fsync,
> 	.flush = cifs_flush,
> 	.mmap  = cifs_file_mmap,
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
> 	.sendfile = generic_file_sendfile,
>+#else
>+	.splice_read = generic_file_splice_read,
>+#endif
> 	.llseek = cifs_llseek,
> #ifdef CONFIG_CIFS_POSIX
> 	.ioctl	= cifs_ioctl,
>@@ -746,7 +797,7 @@ const struct file_operations cifs_file_nobrl_ops = {
> };
> 
> const struct file_operations cifs_file_direct_nobrl_ops = {
>-	/* no mmap, no aio, no readv - 
>+	/* no mmap, no aio, no readv -
> 	   BB reevaluate whether they can be done with directio, no cache */
> 	.read = cifs_user_read,
> 	.write = cifs_user_write,
>@@ -754,7 +805,11 @@ const struct file_operations cifs_file_direct_nobrl_ops = {
> 	.release = cifs_close,
> 	.fsync = cifs_fsync,
> 	.flush = cifs_flush,
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
> 	.sendfile = generic_file_sendfile, /* BB removeme BB */
>+#else
>+	.splice_read = generic_file_splice_read,
>+#endif
> #ifdef CONFIG_CIFS_POSIX
> 	.ioctl  = cifs_ioctl,
> #endif /* CONFIG_CIFS_POSIX */
>@@ -771,28 +826,34 @@ const struct file_operations cifs_dir_ops = {
> #ifdef CONFIG_CIFS_EXPERIMENTAL
> 	.dir_notify = cifs_dir_notify,
> #endif /* CONFIG_CIFS_EXPERIMENTAL */
>-        .ioctl  = cifs_ioctl,
>+	.ioctl  = cifs_ioctl,
> };
> 
>+#ifndef SLAB_MEM_SPREAD
>+#define SLAB_MEM_SPREAD 0
>+#endif
>+
> static void
>-cifs_init_once(void *inode, kmem_cache_t * cachep, unsigned long flags)
>+cifs_init_once(void *inode, struct kmem_cache *cachep, unsigned long flags)
> {
> 	struct cifsInodeInfo *cifsi = inode;
> 
>-	if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
>-	    SLAB_CTOR_CONSTRUCTOR) {
>-		inode_init_once(&cifsi->vfs_inode);
>-		INIT_LIST_HEAD(&cifsi->lockList);
>-	}
>+	inode_init_once(&cifsi->vfs_inode);
>+	INIT_LIST_HEAD(&cifsi->lockList);
> }
> 
> static int
> cifs_init_inodecache(void)
> {
> 	cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
>-					      sizeof (struct cifsInodeInfo),
>-					      0, SLAB_RECLAIM_ACCOUNT,
>+					      sizeof(struct cifsInodeInfo),
>+					      0, (SLAB_RECLAIM_ACCOUNT|
>+						SLAB_MEM_SPREAD),
>+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22)
>+					      cifs_init_once);
>+#else
> 					      cifs_init_once, NULL);
>+#endif
> 	if (cifs_inode_cachep == NULL)
> 		return -ENOMEM;
> 
>@@ -808,7 +869,7 @@ cifs_destroy_inodecache(void)
> static int
> cifs_init_request_bufs(void)
> {
>-	if(CIFSMaxBufSize < 8192) {
>+	if (CIFSMaxBufSize < 8192) {
> 	/* Buffer size can not be smaller than 2 * PATH_MAX since maximum
> 	Unicode path name has to fit in any SMB/CIFS path based frames */
> 		CIFSMaxBufSize = 8192;
>@@ -821,56 +882,60 @@ cifs_init_request_bufs(void)
> 	cifs_req_cachep = kmem_cache_create("cifs_request",
> 					    CIFSMaxBufSize +
> 					    MAX_CIFS_HDR_SIZE, 0,
>+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22)
>+					    SLAB_HWCACHE_ALIGN, NULL);
>+#else
> 					    SLAB_HWCACHE_ALIGN, NULL, NULL);
>+#endif
> 	if (cifs_req_cachep == NULL)
> 		return -ENOMEM;
> 
>-	if(cifs_min_rcv < 1)
>+	if (cifs_min_rcv < 1)
> 		cifs_min_rcv = 1;
> 	else if (cifs_min_rcv > 64) {
> 		cifs_min_rcv = 64;
>-		cERROR(1,("cifs_min_rcv set to maximum (64)"));
>+		cERROR(1, ("cifs_min_rcv set to maximum (64)"));
> 	}
> 
>-	cifs_req_poolp = mempool_create(cifs_min_rcv,
>-					mempool_alloc_slab,
>-					mempool_free_slab,
>-					cifs_req_cachep);
>+	cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
>+						  cifs_req_cachep);
> 
>-	if(cifs_req_poolp == NULL) {
>+	if (cifs_req_poolp == NULL) {
> 		kmem_cache_destroy(cifs_req_cachep);
> 		return -ENOMEM;
> 	}
> 	/* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
> 	almost all handle based requests (but not write response, nor is it
> 	sufficient for path based requests).  A smaller size would have
>-	been more efficient (compacting multiple slab items on one 4k page) 
>+	been more efficient (compacting multiple slab items on one 4k page)
> 	for the case in which debug was on, but this larger size allows
> 	more SMBs to use small buffer alloc and is still much more
>-	efficient to alloc 1 per page off the slab compared to 17K (5page) 
>+	efficient to alloc 1 per page off the slab compared to 17K (5page)
> 	alloc of large cifs buffers even when page debugging is on */
> 	cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
>-			MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN, 
>+			MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
>+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22)
>+			NULL);
>+#else
> 			NULL, NULL);
>+#endif
> 	if (cifs_sm_req_cachep == NULL) {
> 		mempool_destroy(cifs_req_poolp);
> 		kmem_cache_destroy(cifs_req_cachep);
>-		return -ENOMEM;              
>+		return -ENOMEM;
> 	}
> 
>-	if(cifs_min_small < 2)
>+	if (cifs_min_small < 2)
> 		cifs_min_small = 2;
> 	else if (cifs_min_small > 256) {
> 		cifs_min_small = 256;
>-		cFYI(1,("cifs_min_small set to maximum (256)"));
>+		cFYI(1, ("cifs_min_small set to maximum (256)"));
> 	}
> 
>-	cifs_sm_req_poolp = mempool_create(cifs_min_small,
>-				mempool_alloc_slab,
>-				mempool_free_slab,
>-				cifs_sm_req_cachep);
>+	cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
>+						     cifs_sm_req_cachep);
> 
>-	if(cifs_sm_req_poolp == NULL) {
>+	if (cifs_sm_req_poolp == NULL) {
> 		mempool_destroy(cifs_req_poolp);
> 		kmem_cache_destroy(cifs_req_cachep);
> 		kmem_cache_destroy(cifs_sm_req_cachep);
>@@ -893,26 +958,32 @@ static int
> cifs_init_mids(void)
> {
> 	cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
>-				sizeof (struct mid_q_entry), 0,
>-				SLAB_HWCACHE_ALIGN, NULL, NULL);
>+					    sizeof(struct mid_q_entry), 0,
>+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22)
>+					    SLAB_HWCACHE_ALIGN, NULL);
>+#else
>+					    SLAB_HWCACHE_ALIGN, NULL, NULL);
>+#endif
> 	if (cifs_mid_cachep == NULL)
> 		return -ENOMEM;
> 
>-	cifs_mid_poolp = mempool_create(3 /* a reasonable min simultan opers */,
>-					mempool_alloc_slab,
>-					mempool_free_slab,
>-					cifs_mid_cachep);
>-	if(cifs_mid_poolp == NULL) {
>+	/* 3 is a reasonable minimum number of simultaneous operations */
>+	cifs_mid_poolp = mempool_create_slab_pool(3, 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",
>-				sizeof (struct oplock_q_entry), 0,
>-				SLAB_HWCACHE_ALIGN, NULL, NULL);
>+					sizeof(struct oplock_q_entry), 0,
>+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22)
>+					SLAB_HWCACHE_ALIGN, NULL);
>+#else
>+					SLAB_HWCACHE_ALIGN, NULL, NULL);
>+#endif
> 	if (cifs_oplock_cachep == NULL) {
>-		kmem_cache_destroy(cifs_mid_cachep);
> 		mempool_destroy(cifs_mid_poolp);
>+		kmem_cache_destroy(cifs_mid_cachep);
> 		return -ENOMEM;
> 	}
> 
>@@ -927,47 +998,48 @@ cifs_destroy_mids(void)
> 	kmem_cache_destroy(cifs_oplock_cachep);
> }
> 
>-static int cifs_oplock_thread(void * dummyarg)
>+static int cifs_oplock_thread(void *dummyarg)
> {
>-	struct oplock_q_entry * oplock_item;
>+	struct oplock_q_entry *oplock_item;
> 	struct cifsTconInfo *pTcon;
>-	struct inode * inode;
>+	struct inode *inode;
> 	__u16  netfid;
> 	int rc;
> 
>-	daemonize("cifsoplockd");
>-	allow_signal(SIGTERM);
>-
>-	oplockThread = current;
>+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22)
>+	set_freezable();
>+#endif
> 	do {
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 12)
>-		if (try_to_freeze()) 
>+		if (try_to_freeze())
> 			continue;
> #endif
>-		
>+
> 		spin_lock(&GlobalMid_Lock);
>-		if(list_empty(&GlobalOplock_Q)) {
>+		if (list_empty(&GlobalOplock_Q)) {
> 			spin_unlock(&GlobalMid_Lock);
> 			set_current_state(TASK_INTERRUPTIBLE);
> 			schedule_timeout(39*HZ);
> 		} else {
>-			oplock_item = list_entry(GlobalOplock_Q.next, 
>+			oplock_item = list_entry(GlobalOplock_Q.next,
> 				struct oplock_q_entry, qhead);
>-			if(oplock_item) {
>-				cFYI(1,("found oplock item to write out")); 
>+			if (oplock_item) {
>+				cFYI(1, ("found oplock item to write out"));
> 				pTcon = oplock_item->tcon;
> 				inode = oplock_item->pinode;
> 				netfid = oplock_item->netfid;
> 				spin_unlock(&GlobalMid_Lock);
> 				DeleteOplockQEntry(oplock_item);
> 				/* can not grab inode sem here since it would
>-				deadlock when oplock received on delete 
>+				deadlock when oplock received on delete
> 				since vfs_unlink holds the i_mutex across
> 				the call */
> 				/* mutex_lock(&inode->i_mutex);*/
> 				if (S_ISREG(inode->i_mode)) {
>-					rc = filemap_fdatawrite(inode->i_mapping);
>-					if(CIFS_I(inode)->clientCanCacheRead == 0) {
>+					rc =
>+					   filemap_fdatawrite(inode->i_mapping);
>+					if (CIFS_I(inode)->clientCanCacheRead
>+									 == 0) {
> 						filemap_fdatawait(inode->i_mapping);
> 						invalidate_remote_inode(inode);
> 					}
>@@ -976,40 +1048,37 @@ static int cifs_oplock_thread(void * dummyarg)
> 				/* mutex_unlock(&inode->i_mutex);*/
> 				if (rc)
> 					CIFS_I(inode)->write_behind_rc = rc;
>-				cFYI(1,("Oplock flush inode %p rc %d",inode,rc));
>-
>-				/* releasing a stale oplock after recent reconnection 
>-				of smb session using a now incorrect file 
>-				handle is not a data integrity issue but do  
>-				not bother sending an oplock release if session 
>-				to server still is disconnected since oplock 
>+				cFYI(1, ("Oplock flush inode %p rc %d",
>+					inode, rc));
>+
>+				/* releasing stale oplock after recent reconnect
>+				of smb session using a now incorrect file
>+				handle is not a data integrity issue but do
>+				not bother sending an oplock release if session
>+				to server still is disconnected since oplock
> 				already released by the server in that case */
>-				if(pTcon->tidStatus != CifsNeedReconnect) {
>+				if (pTcon->tidStatus != CifsNeedReconnect) {
> 				    rc = CIFSSMBLock(0, pTcon, netfid,
>-					    0 /* len */ , 0 /* offset */, 0, 
>+					    0 /* len */ , 0 /* offset */, 0,
> 					    0, LOCKING_ANDX_OPLOCK_RELEASE,
> 					    0 /* wait flag */);
>-					cFYI(1,("Oplock release rc = %d ",rc));
>+					cFYI(1, ("Oplock release rc = %d", rc));
> 				}
> 			} else
> 				spin_unlock(&GlobalMid_Lock);
> 			set_current_state(TASK_INTERRUPTIBLE);
> 			schedule_timeout(1);  /* yield in case q were corrupt */
> 		}
>-	} while(!signal_pending(current));
>-	oplockThread = NULL;
>-	complete_and_exit (&cifs_oplock_exited, 0);
>+	} while (!kthread_should_stop());
>+
>+	return 0;
> }
> 
>-static int cifs_dnotify_thread(void * dummyarg)
>+static int cifs_dnotify_thread(void *dummyarg)
> {
> 	struct list_head *tmp;
> 	struct cifsSesInfo *ses;
> 
>-	daemonize("cifsdnotifyd");
>-	allow_signal(SIGTERM);
>-
>-	dnotifyThread = current;
> 	do {
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 12)
> 		if (try_to_freeze())
>@@ -1022,15 +1091,16 @@ static int cifs_dnotify_thread(void * dummyarg)
> 		   to be woken up and wakeq so the
> 		   thread can wake up and error out */
> 		list_for_each(tmp, &GlobalSMBSessionList) {
>-			ses = list_entry(tmp, struct cifsSesInfo, 
>+			ses = list_entry(tmp, struct cifsSesInfo,
> 				cifsSessionList);
>-			if(ses && ses->server && 
>+			if (ses && ses->server &&
> 			     atomic_read(&ses->server->inFlight))
> 				wake_up_all(&ses->server->response_q);
> 		}
> 		read_unlock(&GlobalSMBSeslock);
>-	} while(!signal_pending(current));
>-	complete_and_exit (&cifs_dnotify_exited, 0);
>+	} while (!kthread_should_stop());
>+
>+	return 0;
> }
> 
> static int __init
>@@ -1047,13 +1117,13 @@ init_cifs(void)
> #ifdef CONFIG_CIFS_EXPERIMENTAL
> 	INIT_LIST_HEAD(&GlobalDnotifyReqList);
> 	INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
>-#endif	
>+#endif
> /*
>  *  Initialize Global counters
>  */
> 	atomic_set(&sesInfoAllocCount, 0);
> 	atomic_set(&tconInfoAllocCount, 0);
>-	atomic_set(&tcpSesAllocCount,0);
>+	atomic_set(&tcpSesAllocCount, 0);
> 	atomic_set(&tcpSesReconnectCount, 0);
> 	atomic_set(&tconInfoReconnectCount, 0);
> 
>@@ -1068,44 +1138,61 @@ init_cifs(void)
> 	GlobalCurrentXid = 0;
> 	GlobalTotalActiveXid = 0;
> 	GlobalMaxActiveXid = 0;
>+	memset(Local_System_Name, 0, 15);
> 	rwlock_init(&GlobalSMBSeslock);
> 	spin_lock_init(&GlobalMid_Lock);
> 
>-	if(cifs_max_pending < 2) {
>+	if (cifs_max_pending < 2) {
> 		cifs_max_pending = 2;
>-		cFYI(1,("cifs_max_pending set to min of 2"));
>-	} else if(cifs_max_pending > 256) {
>+		cFYI(1, ("cifs_max_pending set to min of 2"));
>+	} else if (cifs_max_pending > 256) {
> 		cifs_max_pending = 256;
>-		cFYI(1,("cifs_max_pending set to max of 256"));
>+		cFYI(1, ("cifs_max_pending set to max of 256"));
> 	}
> 
> 	rc = cifs_init_inodecache();
>-	if (!rc) {
>-		rc = cifs_init_mids();
>-		if (!rc) {
>-			rc = cifs_init_request_bufs();
>-			if (!rc) {
>-				rc = register_filesystem(&cifs_fs_type);
>-				if (!rc) {                
>-					rc = (int)kernel_thread(cifs_oplock_thread, NULL, 
>-						CLONE_FS | CLONE_FILES | CLONE_VM);
>-					if(rc > 0) {
>-						rc = (int)kernel_thread(cifs_dnotify_thread, NULL,
>-							CLONE_FS | CLONE_FILES | CLONE_VM);
>-						if(rc > 0)
>-							return 0;
>-						else
>-							cERROR(1,("error %d create dnotify thread", rc));
>-					} else {
>-						cERROR(1,("error %d create oplock thread",rc));
>-					}
>-				}
>-				cifs_destroy_request_bufs();
>-			}
>-			cifs_destroy_mids();
>-		}
>-		cifs_destroy_inodecache();
>+	if (rc)
>+		goto out_clean_proc;
>+
>+	rc = cifs_init_mids();
>+	if (rc)
>+		goto out_destroy_inodecache;
>+
>+	rc = cifs_init_request_bufs();
>+	if (rc)
>+		goto out_destroy_mids;
>+
>+	rc = register_filesystem(&cifs_fs_type);
>+	if (rc)
>+		goto out_destroy_request_bufs;
>+
>+	oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
>+	if (IS_ERR(oplockThread)) {
>+		rc = PTR_ERR(oplockThread);
>+		cERROR(1, ("error %d create oplock thread", rc));
>+		goto out_unregister_filesystem;
>+	}
>+
>+	dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
>+	if (IS_ERR(dnotifyThread)) {
>+		rc = PTR_ERR(dnotifyThread);
>+		cERROR(1, ("error %d create dnotify thread", rc));
>+		goto out_stop_oplock_thread;
> 	}
>+
>+	return 0;
>+
>+ out_stop_oplock_thread:
>+	kthread_stop(oplockThread);
>+ out_unregister_filesystem:
>+	unregister_filesystem(&cifs_fs_type);
>+ out_destroy_request_bufs:
>+	cifs_destroy_request_bufs();
>+ out_destroy_mids:
>+	cifs_destroy_mids();
>+ out_destroy_inodecache:
>+	cifs_destroy_inodecache();
>+ out_clean_proc:
> #ifdef CONFIG_PROC_FS
> 	cifs_proc_clean();
> #endif
>@@ -1115,7 +1202,7 @@ init_cifs(void)
> static void __exit
> exit_cifs(void)
> {
>-	cFYI(0, ("In unregister ie exit_cifs"));
>+	cFYI(0, ("exit_cifs"));
> #ifdef CONFIG_PROC_FS
> 	cifs_proc_clean();
> #endif
>@@ -1123,20 +1210,15 @@ exit_cifs(void)
> 	cifs_destroy_inodecache();
> 	cifs_destroy_mids();
> 	cifs_destroy_request_bufs();
>-	if(oplockThread) {
>-		send_sig(SIGTERM, oplockThread, 1);
>-		wait_for_completion(&cifs_oplock_exited);
>-	}
>-	if(dnotifyThread) {
>-		send_sig(SIGTERM, dnotifyThread, 1);
>-		wait_for_completion(&cifs_dnotify_exited);
>-	}
>+	kthread_stop(oplockThread);
>+	kthread_stop(dnotifyThread);
> }
> 
> MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
>-MODULE_LICENSE("GPL");		/* combination of LGPL + GPL source behaves as GPL */
>+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");
>+    ("VFS to access servers complying with the SNIA CIFS Specification "
>+     "e.g. Samba and Windows");
> MODULE_VERSION(CIFS_VERSION);
> module_init(init_cifs)
> module_exit(exit_cifs)
>diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
>index 75ade9b..57e22ef 100644
>--- a/fs/cifs/cifsfs.h
>+++ b/fs/cifs/cifsfs.h
>@@ -16,7 +16,7 @@
>  *
>  *   You should have received a copy of the GNU Lesser General Public License
>  *   along with this library; if not, write to the Free Software
>- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
>+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>  */
> 
> #ifndef _CIFSFS_H
>@@ -32,10 +32,6 @@
> #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
>@@ -69,13 +65,13 @@ extern const struct address_space_operations cifs_addr_ops;
> extern const struct address_space_operations cifs_addr_ops_smallbuf;
> 
> /* Functions related to super block operations */
>-extern struct super_operations cifs_super_ops;
>+/* extern const struct super_operations cifs_super_ops;*/
> extern void cifs_read_inode(struct inode *);
> /*extern void cifs_delete_inode(struct inode *);*/  /* BB not needed yet */
> /* extern void cifs_write_inode(struct inode *); */ /* BB not needed yet */
> 
> /* Functions related to inodes */
>-extern struct inode_operations cifs_dir_inode_ops;
>+extern const struct inode_operations cifs_dir_inode_ops;
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
> extern int cifs_create(struct inode *, struct dentry *, int, 
> 		       struct nameidata *);
>@@ -97,21 +93,21 @@ extern int cifs_rename(struct inode *, struct dentry *, struct inode *,
> extern int cifs_revalidate(struct dentry *);
> extern int cifs_setattr(struct dentry *, struct iattr *);
> 
>-extern struct inode_operations cifs_file_inode_ops;
>-extern struct inode_operations cifs_symlink_inode_ops;
>+extern const struct inode_operations cifs_file_inode_ops;
>+extern const struct inode_operations cifs_symlink_inode_ops;
> 
> /* Functions related to files and directories */
> extern const struct file_operations cifs_file_ops;
>-extern const struct file_operations cifs_file_direct_ops; /* if directio mount */
>+extern const struct file_operations cifs_file_direct_ops; /* if directio mnt */
> extern const struct file_operations cifs_file_nobrl_ops;
>-extern const struct file_operations cifs_file_direct_nobrl_ops; /* if directio mount */
>+extern const struct file_operations cifs_file_direct_nobrl_ops; /* no brlocks */
> extern int cifs_open(struct inode *inode, struct file *file);
> extern int cifs_close(struct inode *inode, struct file *file);
> extern int cifs_closedir(struct inode *inode, struct file *file);
> extern ssize_t cifs_user_read(struct file *file, char __user *read_data,
>-			 size_t read_size, loff_t * poffset);
>+			 size_t read_size, loff_t *poffset);
> extern ssize_t cifs_user_write(struct file *file, const char __user *write_data,
>-			 size_t write_size, loff_t * poffset);
>+			 size_t write_size, loff_t *poffset);
> extern int cifs_lock(struct file *, int, struct file_lock *);
> extern int cifs_fsync(struct file *, struct dentry *, int);
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)
>@@ -132,12 +128,13 @@ extern struct dentry_operations cifs_ci_dentry_ops;
> /* Functions related to symlinks */
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,12)
> extern void *cifs_follow_link(struct dentry *direntry, struct nameidata *nd);
>-extern void cifs_put_link(struct dentry *direntry, struct nameidata *nd, void *);
>+extern void cifs_put_link(struct dentry *direntry,
>+			  struct nameidata *nd, void *);
> #else
> extern int cifs_follow_link(struct dentry *direntry, struct nameidata *nd);
> extern void cifs_put_link(struct dentry *direntry, struct nameidata *nd);
> #endif
>-extern int cifs_readlink(struct dentry *direntry, char __user *buffer, 
>+extern int cifs_readlink(struct dentry *direntry, char __user *buffer,
> 			 int buflen);
> extern int cifs_symlink(struct inode *inode, struct dentry *direntry,
> 			const char *symname);
>@@ -146,7 +143,7 @@ extern int 	cifs_setxattr(struct dentry *, const char *, const void *,
> 			size_t, int);
> extern ssize_t	cifs_getxattr(struct dentry *, const char *, void *, size_t);
> extern ssize_t	cifs_listxattr(struct dentry *, char *, size_t);
>-extern int cifs_ioctl (struct inode * inode, struct file * filep,
>+extern int cifs_ioctl(struct inode *inode, struct file *filep,
> 		       unsigned int command, unsigned long arg);
>-#define CIFS_VERSION   "1.48aRH"
>+#define CIFS_VERSION   "1.51"
> #endif				/* _CIFSFS_H */
>diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
>index 7cafa38..e75aa07 100644
>--- a/fs/cifs/cifsglob.h
>+++ b/fs/cifs/cifsglob.h
>@@ -14,7 +14,7 @@
>  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
>  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
>  *   the GNU Lesser General Public License for more details.
>- * 
>+ *
>  */
> #include <linux/in.h>
> #include <linux/in6.h>
>@@ -29,7 +29,7 @@
> 
> #define MAX_TREE_SIZE 2 + MAX_SERVER_SIZE + 1 + MAX_SHARE_SIZE + 1
> #define MAX_SERVER_SIZE 15
>-#define MAX_SHARE_SIZE  64	/* used to be 20 - this should still be enough */
>+#define MAX_SHARE_SIZE  64	/* used to be 20, this should still be enough */
> #define MAX_USERNAME_SIZE 32	/* 32 is to allow for 15 char names + null
> 				   termination then *2 for unicode versions */
> #define MAX_PASSWORD_SIZE 16
>@@ -39,13 +39,13 @@
> /*
>  * MAX_REQ is the maximum number of requests that WE will send
>  * on one socket concurently. It also matches the most common
>- * value of max multiplex returned by servers.  We may 
>+ * value of max multiplex returned by servers.  We may
>  * eventually want to use the negotiated value (in case
>  * future servers can handle more) when we are more confident that
>  * we will not have problems oveloading the socket with pending
>  * write data.
>  */
>-#define CIFS_MAX_REQ 50 
>+#define CIFS_MAX_REQ 50
> 
> #define SERVER_NAME_LENGTH 15
> #define SERVER_NAME_LEN_WITH_NULL     (SERVER_NAME_LENGTH + 1)
>@@ -113,6 +113,17 @@ enum protocolEnum {
> 	/* Netbios frames protocol not supported at this time */
> };
> 
>+struct mac_key {
>+	unsigned int len;
>+	union {
>+		char ntlm[CIFS_SESS_KEY_SIZE + 16];
>+		struct {
>+			char key[16];
>+			struct ntlmv2_resp resp;
>+		} ntlmv2;
>+	} data;
>+};
>+
> /*
>  *****************************************************************
>  * Except the CIFS PDUs themselves all the
>@@ -129,13 +140,13 @@ struct TCP_Server_Info {
> 		struct sockaddr_in sockAddr;
> 		struct sockaddr_in6 sockAddr6;
> 	} addr;
>-	wait_queue_head_t response_q; 
>+	wait_queue_head_t response_q;
> 	wait_queue_head_t request_q; /* if more than maxmpx to srvr must block*/
> 	struct list_head pending_mid_q;
> 	void *Server_NlsInfo;	/* BB - placeholder for future NLS info  */
> 	unsigned short server_codepage;	/* codepage for the server    */
> 	unsigned long ip_address;	/* IP addr for the server if known */
>-	enum protocolEnum protocolType;	
>+	enum protocolEnum protocolType;
> 	char versionMajor;
> 	char versionMinor;
> 	unsigned svlocal:1;	/* local server or remote */
>@@ -168,14 +179,15 @@ struct TCP_Server_Info {
> 	/* 16th byte of RFC1001 workstation name is always null */
> 	char workstation_RFC1001_name[SERVER_NAME_LEN_WITH_NULL];
> 	__u32 sequence_number; /* needed for CIFS PDU signature */
>-	char mac_signing_key[CIFS_SESS_KEY_SIZE + 16];
>+	struct mac_key mac_signing_key;
>+	char ntlmv2_hash[16];
> 	unsigned long lstrp; /* when we got last response from this server */
> };
> 
> /*
>  * The following is our shortcut to user information.  We surface the uid,
>  * and name. We always get the password on the fly in case it
>- * has changed. We also hang a list of sessions owned by this user off here. 
>+ * has changed. We also hang a list of sessions owned by this user off here.
>  */
> struct cifsUidInfo {
> 	struct list_head userList;
>@@ -206,11 +218,11 @@ struct cifsSesInfo {
> 	int Suid;		/* remote smb uid  */
> 	uid_t linux_uid;        /* local Linux uid */
> 	int capabilities;
>-	char serverName[SERVER_NAME_LEN_WITH_NULL * 2];	/* BB make bigger for 
>+	char serverName[SERVER_NAME_LEN_WITH_NULL * 2];	/* BB make bigger for
> 				TCP names - will ipv6 and sctp addresses fit? */
> 	char userName[MAX_USERNAME_SIZE + 1];
>-	char * domainName;
>-	char * password;
>+	char *domainName;
>+	char *password;
> };
> /* no more than one of the following three session flags may be set */
> #define CIFS_SES_NT4 1
>@@ -222,7 +234,7 @@ struct cifsSesInfo {
> #define CIFS_SES_LANMAN 8
> /*
>  * there is one of these for each connection to a resource on a particular
>- * session 
>+ * session
>  */
> struct cifsTconInfo {
> 	struct list_head cifsConnectionList;
>@@ -278,7 +290,9 @@ struct cifsTconInfo {
> 	FILE_SYSTEM_UNIX_INFO fsUnixInfo;
> 	unsigned retry:1;
> 	unsigned nocase:1;
>-	/* BB add field for back pointer to sb struct? */
>+	unsigned unix_ext:1; /* if off disable Linux extensions to CIFS protocol
>+				for this mount even if server would support */
>+	/* BB add field for back pointer to sb struct(s)? */
> };
> 
> /*
>@@ -300,9 +314,9 @@ struct cifs_search_info {
> 	__u16 entries_in_buffer;
> 	__u16 info_level;
> 	__u32 resume_key;
>-	char * ntwrk_buf_start;
>-	char * srch_entries_start;
>-	char * presume_name;
>+	char *ntwrk_buf_start;
>+	char *srch_entries_start;
>+	char *presume_name;
> 	unsigned int resume_name_len;
> 	unsigned endOfSearch:1;
> 	unsigned emptyDir:1;
>@@ -318,15 +332,19 @@ struct cifsFileInfo {
> 	__u16 netfid;		/* file id from remote */
> 	/* BB add lock scope info here if needed */ ;
> 	/* lock scope id (0 if none) */
>-	struct file * pfile; /* needed for writepage */
>-	struct inode * pInode; /* needed for oplock break */
>-	struct semaphore lock_sem;
>+	struct file *pfile; /* needed for writepage */
>+	struct inode *pInode; /* needed for oplock break */
>+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)
>+	struct mutex lock_mutex;
>+#else
>+	struct semaphore lock_mutex;
>+#endif
> 	struct list_head llist; /* list of byte range locks we have. */
> 	unsigned closePend:1;	/* file is marked to close */
> 	unsigned invalidHandle:1;  /* file closed via session abend */
> 	atomic_t wrtPending;   /* handle in use - defer close */
> 	struct semaphore fh_sem; /* prevents reopen race after dead ses*/
>-	char * search_resume_name; /* BB removeme BB */
>+	char *search_resume_name; /* BB removeme BB */
> 	struct cifs_search_info srch_inf;
> };
> 
>@@ -336,7 +354,7 @@ struct cifsFileInfo {
> 
> struct cifsInodeInfo {
> 	struct list_head lockList;
>-	/* BB add in lists for dirty pages - i.e. write caching info for oplock */
>+	/* BB add in lists for dirty pages i.e. write caching info for oplock */
> 	struct list_head openFileList;
> 	int write_behind_rc;
> 	__u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */
>@@ -362,7 +380,7 @@ CIFS_SB(struct super_block *sb)
> {
> 	return sb->s_fs_info;
> }
>-#else
>+#else /* 2.4 kernel case */
> static inline struct cifsInodeInfo *
> CIFS_I(struct inode *inode)
> {
>@@ -408,9 +426,9 @@ static inline void cifs_stats_bytes_read(struct cifsTconInfo *tcon,
> }
> #else
> 
>-#define  cifs_stats_inc(field) do {} while(0)
>-#define  cifs_stats_bytes_written(tcon, bytes) do {} while(0)
>-#define  cifs_stats_bytes_read(tcon, bytes) do {} while(0)
>+#define  cifs_stats_inc(field) do {} while (0)
>+#define  cifs_stats_bytes_written(tcon, bytes) do {} while (0)
>+#define  cifs_stats_bytes_read(tcon, bytes) do {} while (0)
> 
> #endif
> 
>@@ -437,8 +455,8 @@ struct mid_q_entry {
> 
> struct oplock_q_entry {
> 	struct list_head qhead;
>-	struct inode * pinode;
>-	struct cifsTconInfo * tcon; 
>+	struct inode *pinode;
>+	struct cifsTconInfo *tcon;
> 	__u16 netfid;
> };
> 
>@@ -453,7 +471,7 @@ struct dir_notify_req {
>        __u16 netfid;
>        __u32 filter; /* CompletionFilter (for multishot) */
>        int multishot;
>-       struct file * pfile;
>+       struct file *pfile;
> };
> 
> #define   MID_FREE 0
>@@ -491,7 +509,7 @@ require use of the stronger protocol */
> #define   CIFSSEC_MUST_LANMAN	0x10010
> #define   CIFSSEC_MUST_PLNTXT	0x20020
> #define   CIFSSEC_MASK          0x37037 /* current flags supported if weak */
>-#else	  
>+#else
> #define	  CIFSSEC_MASK          0x07007 /* flags supported if no weak config */
> #endif /* WEAK_PW_HASH */
> #define   CIFSSEC_MUST_SEAL	0x40040 /* not supported yet */
>@@ -529,7 +547,7 @@ require use of the stronger protocol */
>  *  ----------
>  *  sesSem     operations on smb session
>  *  tconSem    operations on tree connection
>- *  fh_sem      file handle reconnection operations 
>+ *  fh_sem      file handle reconnection operations
>  *
>  ****************************************************************************/
> 
>@@ -542,9 +560,10 @@ require use of the stronger protocol */
> /*
>  * The list of servers that did not respond with NT LM 0.12.
>  * This list helps improve performance and eliminate the messages indicating
>- * that we had a communications error talking to the server in this list. 
>+ * that we had a communications error talking to the server in this list.
>  */
>-GLOBAL_EXTERN struct servers_not_supported *NotSuppList;	/*@z4a */
>+/* Feature not supported */
>+/* GLOBAL_EXTERN struct servers_not_supported *NotSuppList; */
> 
> /*
>  * The following is a hash table of all the users we know about.
>@@ -594,15 +613,14 @@ GLOBAL_EXTERN atomic_t midCount;
> /* Misc globals */
> GLOBAL_EXTERN unsigned int multiuser_mount; /* if enabled allows new sessions
> 				to be established on existing mount if we
>-				have the uid/password or Kerberos credential 
>+				have the uid/password or Kerberos credential
> 				or equivalent for current user */
> GLOBAL_EXTERN unsigned int oplockEnabled;
> GLOBAL_EXTERN unsigned int experimEnabled;
> GLOBAL_EXTERN unsigned int lookupCacheEnabled;
>-GLOBAL_EXTERN unsigned int extended_security;	/* if on, session setup sent 
>+GLOBAL_EXTERN unsigned int extended_security;	/* if on, session setup sent
> 				with more secure ntlmssp2 challenge/resp */
> GLOBAL_EXTERN unsigned int sign_CIFS_PDUs;  /* enable smb packet signing */
>-GLOBAL_EXTERN unsigned int secFlags;
> GLOBAL_EXTERN unsigned int linuxExtEnabled;/*enable Linux/Unix CIFS extensions*/
> GLOBAL_EXTERN unsigned int CIFSMaxBufSize;  /* max size not including hdr */
> GLOBAL_EXTERN unsigned int cifs_min_rcv;    /* min size of big ntwrk buf pool */
>diff --git a/fs/cifs/cifspdu.h b/fs/cifs/cifspdu.h
>index 40d1730..d2010e6 100644
>--- a/fs/cifs/cifspdu.h
>+++ b/fs/cifs/cifspdu.h
>@@ -153,7 +153,7 @@
> #define SMBOPEN_OAPPEND       0x0001
> 
> /*
>- * SMB flag definitions 
>+ * SMB flag definitions
>  */
> #define SMBFLG_EXTD_LOCK 0x01	/* server supports lock-read write-unlock smb */
> #define SMBFLG_RCV_POSTED 0x02	/* obsolete */
>@@ -166,9 +166,9 @@
> #define SMBFLG_RESPONSE 0x80	/* this PDU is a response from server */
> 
> /*
>- * SMB flag2 definitions 
>+ * SMB flag2 definitions
>  */
>-#define SMBFLG2_KNOWS_LONG_NAMES cpu_to_le16(1)	/* can send long (non-8.3) 
>+#define SMBFLG2_KNOWS_LONG_NAMES cpu_to_le16(1)	/* can send long (non-8.3)
> 						   path names in response */
> #define SMBFLG2_KNOWS_EAS cpu_to_le16(2)
> #define SMBFLG2_SECURITY_SIGNATURE cpu_to_le16(4)
>@@ -229,7 +229,7 @@
>  */
> #define CIFS_NO_HANDLE        0xFFFF
> 
>-#define NO_CHANGE_64          0xFFFFFFFFFFFFFFFFULL
>+#define NO_CHANGE_64          cpu_to_le64(0xFFFFFFFFFFFFFFFFULL)
> #define NO_CHANGE_32          0xFFFFFFFFUL
> 
> /* IPC$ in ASCII */
>@@ -269,7 +269,7 @@
> #define ATTR_SPARSE    0x0200
> #define ATTR_REPARSE   0x0400
> #define ATTR_COMPRESSED 0x0800
>-#define ATTR_OFFLINE    0x1000	/* ie file not immediately available - 
>+#define ATTR_OFFLINE    0x1000	/* ie file not immediately available -
> 					on offline storage */
> #define ATTR_NOT_CONTENT_INDEXED 0x2000
> #define ATTR_ENCRYPTED  0x4000
>@@ -309,7 +309,7 @@
> #define CREATE_DELETE_ON_CLOSE	0x00001000
> #define CREATE_OPEN_BY_ID       0x00002000
> #define OPEN_REPARSE_POINT	0x00200000
>-#define CREATE_OPTIONS_MASK     0x007FFFFF 
>+#define CREATE_OPTIONS_MASK     0x007FFFFF
> #define CREATE_OPTION_SPECIAL   0x20000000   /* system. NB not sent over wire */
> 
> /* ImpersonationLevel flags */
>@@ -369,23 +369,25 @@ struct smb_hdr {
> 	__u8 WordCount;
> } __attribute__((packed));
> /* given a pointer to an smb_hdr retrieve the value of byte count */
>-#define BCC(smb_var) ( *(__u16 *)((char *)smb_var + sizeof(struct smb_hdr) + (2* smb_var->WordCount) ) )
>-#define BCC_LE(smb_var) ( *(__le16 *)((char *)smb_var + sizeof(struct smb_hdr) + (2* smb_var->WordCount) ) )
>+#define BCC(smb_var) ( *(__u16 *)((char *)smb_var + sizeof(struct smb_hdr) + (2 * smb_var->WordCount)))
>+#define BCC_LE(smb_var) ( *(__le16 *)((char *)smb_var + sizeof(struct smb_hdr) + (2 * smb_var->WordCount)))
> /* given a pointer to an smb_hdr retrieve the pointer to the byte area */
>-#define pByteArea(smb_var) ((unsigned char *)smb_var + sizeof(struct smb_hdr) + (2* smb_var->WordCount) + 2 )
>+#define pByteArea(smb_var) ((unsigned char *)smb_var + sizeof(struct smb_hdr) + (2 * smb_var->WordCount) + 2)
> 
> /*
>- * Computer Name Length
>+ * Computer Name Length (since Netbios name was length 16 with last byte 0x20)
>+ * No longer as important, now that TCP names are more commonly used to
>+ * resolve hosts.
>  */
> #define CNLEN 15
> 
> /*
>- * Share Name Length					  @S8A
>- * Note:  This length is limited by the SMB used to get   @S8A
>- *        the Share info.   NetShareEnum only returns 13  @S8A
>- *        chars, including the null termination.          @S8A 
>+ * Share Name Length (SNLEN)
>+ * Note:  This length was limited by the SMB used to get
>+ *        the Share info.   NetShareEnum only returned 13
>+ *        chars, including the null termination.
>+ * This was removed because it no longer is limiting.
>  */
>-#define SNLEN 12		/*@S8A */
> 
> /*
>  * Comment Length
>@@ -403,8 +405,8 @@ struct smb_hdr {
>  *
>  *  The Naming convention is the lower case version of the
>  *  smb command code name for the struct and this is typedef to the
>- *  uppercase version of the same name with the prefix SMB_ removed 
>- *  for brevity.  Although typedefs are not commonly used for 
>+ *  uppercase version of the same name with the prefix SMB_ removed
>+ *  for brevity.  Although typedefs are not commonly used for
>  *  structure definitions in the Linux kernel, their use in the
>  *  CIFS standards document, which this code is based on, may
>  *  make this one of the cases where typedefs for structures make
>@@ -412,7 +414,7 @@ struct smb_hdr {
>  *  Typedefs can always be removed later if they are too distracting
>  *  and they are only used for the CIFSs PDUs themselves, not
>  *  internal cifs vfs structures
>- *  
>+ *
>  */
> 
> typedef struct negotiate_req {
>@@ -520,7 +522,7 @@ typedef union smb_com_session_setup_andx {
> 		unsigned char SecurityBlob[1];	/* followed by */
> 		/* STRING NativeOS */
> 		/* STRING NativeLanMan */
>-	} __attribute__((packed)) req;	/* NTLM request format (with 
>+	} __attribute__((packed)) req;	/* NTLM request format (with
> 					extended security */
> 
> 	struct {		/* request format */
>@@ -558,7 +560,7 @@ typedef union smb_com_session_setup_andx {
> /*      unsigned char  * NativeOS;      */
> /*	unsigned char  * NativeLanMan;  */
> /*      unsigned char  * PrimaryDomain; */
>-	} __attribute__((packed)) resp;	/* NTLM response 
>+	} __attribute__((packed)) resp;	/* NTLM response
> 					   (with or without extended sec) */
> 
> 	struct {		/* request format */
>@@ -627,7 +629,7 @@ struct ntlmv2_resp {
> #define CAP_NT_SMBS            0x00000010
> #define CAP_STATUS32           0x00000040
> #define CAP_LEVEL_II_OPLOCKS   0x00000080
>-#define CAP_NT_FIND            0x00000200	/* reserved should be zero 
>+#define CAP_NT_FIND            0x00000200	/* reserved should be zero
> 				(because NT_SMBs implies the same thing?) */
> #define CAP_BULK_TRANSFER      0x20000000
> #define CAP_EXTENDED_SECURITY  0x80000000
>@@ -685,7 +687,7 @@ typedef struct smb_com_logoff_andx_rsp {
> 	__u16 ByteCount;
> } __attribute__((packed)) LOGOFF_ANDX_RSP;
> 
>-typedef union smb_com_tree_disconnect {	/* as an altetnative can use flag on 
>+typedef union smb_com_tree_disconnect {	/* as an altetnative can use flag on
> 					tree_connect PDU to effect disconnect */
> 					/* tdis is probably simplest SMB PDU */
> 	struct {
>@@ -721,6 +723,7 @@ typedef struct smb_com_findclose_req {
> #define REQ_OPLOCK         0x00000002
> #define REQ_BATCHOPLOCK    0x00000004
> #define REQ_OPENDIRONLY    0x00000008
>+#define REQ_EXTENDED_INFO  0x00000010
> 
> typedef struct smb_com_open_req {	/* also handles create */
> 	struct smb_hdr hdr;	/* wct = 24 */
>@@ -808,27 +811,28 @@ typedef struct smb_com_openx_rsp {
> 	__u32  FileId;
> 	__u16  Reserved;
> 	__u16  ByteCount;
>-} __attribute__((packed)) OPENX_RSP; 
>+} __attribute__((packed)) OPENX_RSP;
> 
> /* For encoding of POSIX Open Request - see trans2 function 0x209 data struct */
> 
> /* Legacy write request for older servers */
> typedef struct smb_com_writex_req {
>-        struct smb_hdr hdr;     /* wct = 12 */
>-        __u8 AndXCommand;
>-        __u8 AndXReserved;
>-        __le16 AndXOffset;
>-        __u16 Fid;
>-        __le32 OffsetLow;
>-        __u32 Reserved; /* Timeout */
>-        __le16 WriteMode; /* 1 = write through */
>-        __le16 Remaining;
>-        __le16 Reserved2;
>-        __le16 DataLengthLow;
>-        __le16 DataOffset;
>-        __le16 ByteCount;
>-        __u8 Pad;               /* BB check for whether padded to DWORD boundary and optimum performance here */
>-        char Data[0];
>+	struct smb_hdr hdr;     /* wct = 12 */
>+	__u8 AndXCommand;
>+	__u8 AndXReserved;
>+	__le16 AndXOffset;
>+	__u16 Fid;
>+	__le32 OffsetLow;
>+	__u32 Reserved; /* Timeout */
>+	__le16 WriteMode; /* 1 = write through */
>+	__le16 Remaining;
>+	__le16 Reserved2;
>+	__le16 DataLengthLow;
>+	__le16 DataOffset;
>+	__le16 ByteCount;
>+	__u8 Pad;		/* BB check for whether padded to DWORD
>+				   boundary and optimum performance here */
>+	char Data[0];
> } __attribute__((packed)) WRITEX_REQ;
> 
> typedef struct smb_com_write_req {
>@@ -846,7 +850,8 @@ typedef struct smb_com_write_req {
> 	__le16 DataOffset;
> 	__le32 OffsetHigh;
> 	__le16 ByteCount;
>-	__u8 Pad;		/* BB check for whether padded to DWORD boundary and optimum performance here */
>+	__u8 Pad;		/* BB check for whether padded to DWORD
>+				   boundary and optimum performance here */
> 	char Data[0];
> } __attribute__((packed)) WRITE_REQ;
> 
>@@ -864,17 +869,17 @@ typedef struct smb_com_write_rsp {
> 
> /* legacy read request for older servers */
> typedef struct smb_com_readx_req {
>-        struct smb_hdr hdr;     /* wct = 10 */
>-        __u8 AndXCommand;
>-        __u8 AndXReserved;
>-        __le16 AndXOffset;
>-        __u16 Fid;
>-        __le32 OffsetLow;
>-        __le16 MaxCount;
>-        __le16 MinCount;                /* obsolete */
>-        __le32 Reserved;
>-        __le16 Remaining;
>-        __le16 ByteCount;
>+	struct smb_hdr hdr;	/* wct = 10 */
>+	__u8 AndXCommand;
>+	__u8 AndXReserved;
>+	__le16 AndXOffset;
>+	__u16 Fid;
>+	__le32 OffsetLow;
>+	__le16 MaxCount;
>+	__le16 MinCount;	/* obsolete */
>+	__le32 Reserved;
>+	__le16 Remaining;
>+	__le16 ByteCount;
> } __attribute__((packed)) READX_REQ;
> 
> typedef struct smb_com_read_req {
>@@ -905,7 +910,8 @@ typedef struct smb_com_read_rsp {
> 	__le16 DataLengthHigh;
> 	__u64 Reserved2;
> 	__u16 ByteCount;
>-	__u8 Pad;		/* BB check for whether padded to DWORD boundary and optimum performance here */
>+	__u8 Pad;		/* BB check for whether padded to DWORD
>+				   boundary and optimum performance here */
> 	char Data[1];
> } __attribute__((packed)) READ_RSP;
> 
>@@ -976,7 +982,7 @@ typedef struct smb_com_rename_req {
> #define COPY_TARGET_MODE_ASCII 0x0004 /* if not set, binary */
> #define COPY_SOURCE_MODE_ASCII 0x0008 /* if not set, binary */
> #define COPY_VERIFY_WRITES     0x0010
>-#define COPY_TREE              0x0020 
>+#define COPY_TREE              0x0020
> 
> typedef struct smb_com_copy_req {
> 	struct smb_hdr hdr;	/* wct = 3 */
>@@ -984,7 +990,7 @@ typedef struct smb_com_copy_req {
> 	__le16 OpenFunction;
> 	__le16 Flags;
> 	__le16 ByteCount;
>-	__u8 BufferFormat;	/* 4 = ASCII or Unicode */ 
>+	__u8 BufferFormat;	/* 4 = ASCII or Unicode */
> 	unsigned char OldFileName[1];
> 	/* followed by __u8 BufferFormat2 */
> 	/* followed by NewFileName string */
>@@ -1092,28 +1098,28 @@ typedef struct smb_com_setattr_rsp {
> 
> /*******************************************************/
> /* NT Transact structure defintions follow             */
>-/* Currently only ioctl, acl (get security descriptor) */  
>+/* Currently only ioctl, acl (get security descriptor) */
> /* and notify are implemented                          */
> /*******************************************************/
> typedef struct smb_com_ntransact_req {
>-        struct smb_hdr hdr; /* wct >= 19 */
>-        __u8 MaxSetupCount;
>-        __u16 Reserved;
>-        __le32 TotalParameterCount;
>-        __le32 TotalDataCount;
>-        __le32 MaxParameterCount;
>-        __le32 MaxDataCount;
>-        __le32 ParameterCount;
>-        __le32 ParameterOffset;
>-        __le32 DataCount;
>-        __le32 DataOffset;
>-        __u8 SetupCount; /* four setup words follow subcommand */
>-        /* SNIA spec incorrectly included spurious pad here */
>-        __le16 SubCommand; /* 2 = IOCTL/FSCTL */
>-	/* SetupCount words follow then */ 
>-        __le16 ByteCount;
>-        __u8 Pad[3];
>-        __u8 Parms[0];
>+	struct smb_hdr hdr; /* wct >= 19 */
>+	__u8 MaxSetupCount;
>+	__u16 Reserved;
>+	__le32 TotalParameterCount;
>+	__le32 TotalDataCount;
>+	__le32 MaxParameterCount;
>+	__le32 MaxDataCount;
>+	__le32 ParameterCount;
>+	__le32 ParameterOffset;
>+	__le32 DataCount;
>+	__le32 DataOffset;
>+	__u8 SetupCount; /* four setup words follow subcommand */
>+	/* SNIA spec incorrectly included spurious pad here */
>+	__le16 SubCommand; /* 2 = IOCTL/FSCTL */
>+	/* SetupCount words follow then */
>+	__le16 ByteCount;
>+	__u8 Pad[3];
>+	__u8 Parms[0];
> } __attribute__((packed)) NTRANSACT_REQ;
> 
> typedef struct smb_com_ntransact_rsp {
>@@ -1129,7 +1135,7 @@ typedef struct smb_com_ntransact_rsp {
> 	__le32 DataDisplacement;
> 	__u8 SetupCount;   /* 0 */
> 	__u16 ByteCount;
>-        /* __u8 Pad[3]; */
>+	/* __u8 Pad[3]; */
> 	/* parms and data follow */
> } __attribute__((packed)) NTRANSACT_RSP;
> 
>@@ -1224,7 +1230,7 @@ typedef struct smb_com_transaction_change_notify_req {
> /*	__u8 Data[1];*/
> } __attribute__((packed)) TRANSACT_CHANGE_NOTIFY_REQ;
> 
>-/* BB eventually change to use generic ntransact rsp struct 
>+/* BB eventually change to use generic ntransact rsp struct
>       and validation routine */
> typedef struct smb_com_transaction_change_notify_rsp {
> 	struct smb_hdr hdr;	/* wct = 18 */
>@@ -1271,7 +1277,7 @@ struct file_notify_information {
> 	__le32 Action;
> 	__le32 FileNameLength;
> 	__u8  FileName[0];
>-} __attribute__((packed)); 
>+} __attribute__((packed));
> 
> struct reparse_data {
> 	__u32	ReparseTag;
>@@ -1340,7 +1346,7 @@ struct trans2_resp {
> 	__u8 Reserved1;
> 	/* SetupWords[SetupCount];
> 	__u16 ByteCount;
>-	__u16 Reserved2;*/	
>+	__u16 Reserved2;*/
> 	/* data area follows */
> } __attribute__((packed));
> 
>@@ -1379,9 +1385,9 @@ struct smb_t2_rsp {
> #define SMB_QUERY_FILE_INTERNAL_INFO    0x3ee
> #define SMB_QUERY_FILE_ACCESS_INFO      0x3f0
> #define SMB_QUERY_FILE_NAME_INFO2       0x3f1 /* 0x30 bytes */
>-#define SMB_QUERY_FILE_POSITION_INFO    0x3f6 
>+#define SMB_QUERY_FILE_POSITION_INFO    0x3f6
> #define SMB_QUERY_FILE_MODE_INFO        0x3f8
>-#define SMB_QUERY_FILE_ALGN_INFO        0x3f9 
>+#define SMB_QUERY_FILE_ALGN_INFO        0x3f9
> 
> 
> #define SMB_SET_FILE_BASIC_INFO	        0x101
>@@ -1397,7 +1403,7 @@ struct smb_t2_rsp {
> #define SMB_SET_POSIX_LOCK              0x208
> #define SMB_POSIX_OPEN                  0x209
> #define SMB_POSIX_UNLINK                0x20a
>-#define SMB_SET_FILE_UNIX_INFO2
>+#define SMB_SET_FILE_UNIX_INFO2         0x20b
> #define SMB_SET_FILE_BASIC_INFO2        0x3ec
> #define SMB_SET_FILE_RENAME_INFORMATION 0x3f2 /* BB check if qpathinfo too */
> #define SMB_FILE_ALL_INFO2              0x3fa
>@@ -1515,35 +1521,35 @@ struct smb_com_transaction2_sfi_req {
> 	__u16 Pad1;
> 	__u16 Fid;
> 	__le16 InformationLevel;
>-	__u16 Reserved4;	
>+	__u16 Reserved4;
> } __attribute__((packed));
> 
> struct smb_com_transaction2_sfi_rsp {
> 	struct smb_hdr hdr;	/* wct = 10 + SetupCount */
> 	struct trans2_resp t2;
> 	__u16 ByteCount;
>-	__u16 Reserved2;	/* parameter word reserved - 
>+	__u16 Reserved2;	/* parameter word reserved -
> 					present for infolevels > 100 */
> } __attribute__((packed));
> 
> struct smb_t2_qfi_req {
>-        struct	smb_hdr hdr;
>-        struct	trans2_req t2;
>+	struct	smb_hdr hdr;
>+	struct	trans2_req t2;
> 	__u8	Pad;
> 	__u16	Fid;
> 	__le16	InformationLevel;
> } __attribute__((packed));
> 
> struct smb_t2_qfi_rsp {
>-        struct smb_hdr hdr;     /* wct = 10 + SetupCount */
>-        struct trans2_resp t2;
>-        __u16 ByteCount;
>-        __u16 Reserved2;        /* parameter word reserved - 
>-					present for infolevels > 100 */
>+	struct smb_hdr hdr;     /* wct = 10 + SetupCount */
>+	struct trans2_resp t2;
>+	__u16 ByteCount;
>+	__u16 Reserved2;        /* parameter word reserved -
>+				   present for infolevels > 100 */
> } __attribute__((packed));
> 
> /*
>- * Flags on T2 FINDFIRST and FINDNEXT 
>+ * Flags on T2 FINDFIRST and FINDNEXT
>  */
> #define CIFS_SEARCH_CLOSE_ALWAYS  0x0001
> #define CIFS_SEARCH_CLOSE_AT_END  0x0002
>@@ -1752,7 +1758,9 @@ typedef struct smb_com_transaction2_get_dfs_refer_req {
> 	__u8 Reserved3;
> 	__le16 SubCommand;	/* one setup word */
> 	__le16 ByteCount;
>-	__u8 Pad[3];		/* Win2K has sent 0x0F01 (max resp length perhaps?) followed by one byte pad - doesn't seem to matter though */
>+	__u8 Pad[3];		/* Win2K has sent 0x0F01 (max response length
>+				   perhaps?) followed by one byte pad - doesn't
>+				   seem to matter though */
> 	__le16 MaxReferralLevel;
> 	char RequestFileName[1];
> } __attribute__((packed)) TRANSACTION2_GET_DFS_REFER_REQ;
>@@ -1761,7 +1769,10 @@ typedef struct dfs_referral_level_3 {
> 	__le16 VersionNumber;
> 	__le16 ReferralSize;
> 	__le16 ServerType;	/* 0x0001 = CIFS server */
>-	__le16 ReferralFlags;	/* or proximity - not clear which since always set to zero - SNIA spec says 0x01 means strip off PathConsumed chars before submitting RequestFileName to remote node */
>+	__le16 ReferralFlags;	/* or proximity - not clear which since it is
>+				   always set to zero - SNIA spec says 0x01
>+				   means strip off PathConsumed chars before
>+				   submitting RequestFileName to remote node */
> 	__le16 TimeToLive;
> 	__le16 Proximity;
> 	__le16 DfsPathOffset;
>@@ -1787,11 +1798,13 @@ typedef struct smb_com_transaction_get_dfs_refer_rsp {
> #define DFSREF_STORAGE_SERVER   0x0002
> 
> /* IOCTL information */
>-/* List of ioctl function codes that look to be of interest to remote clients like this. */
>-/* Need to do some experimentation to make sure they all work remotely.                  */
>-/* Some of the following such as the encryption/compression ones would be                */
>-/* invoked from tools via a specialized hook into the VFS rather than via the            */
>-/* standard vfs entry points */
>+/*
>+ * List of ioctl function codes that look to be of interest to remote clients
>+ * like this one.  Need to do some experimentation to make sure they all work
>+ * remotely.  Some of the following, such as the encryption/compression ones
>+ * would be invoked from tools via a specialized hook into the VFS rather
>+ * than via the standard vfs entry points
>+ */
> #define FSCTL_REQUEST_OPLOCK_LEVEL_1 0x00090000
> #define FSCTL_REQUEST_OPLOCK_LEVEL_2 0x00090004
> #define FSCTL_REQUEST_BATCH_OPLOCK   0x00090008
>@@ -1820,7 +1833,7 @@ typedef struct smb_com_transaction_get_dfs_refer_rsp {
> /*
>  ************************************************************************
>  * All structs for everything above the SMB PDUs themselves
>- * (such as the T2 level specific data) go here                  
>+ * (such as the T2 level specific data) go here
>  ************************************************************************
>  */
> 
>@@ -1866,7 +1879,7 @@ typedef struct {
> 	__le64 FreeAllocationUnits;
> 	__le32 SectorsPerAllocationUnit;
> 	__le32 BytesPerSector;
>-} __attribute__((packed)) FILE_SYSTEM_INFO;		/* size info, level 0x103 */
>+} __attribute__((packed)) FILE_SYSTEM_INFO;	/* size info, level 0x103 */
> 
> typedef struct {
> 	__le32 fsid;
>@@ -1880,7 +1893,7 @@ typedef struct {
> 	__le16 MajorVersionNumber;
> 	__le16 MinorVersionNumber;
> 	__le64 Capability;
>-} __attribute__((packed)) FILE_SYSTEM_UNIX_INFO;	/* Unix extensions info, level 0x200 */
>+} __attribute__((packed)) FILE_SYSTEM_UNIX_INFO; /* Unix extension level 0x200*/
> 
> /* Version numbers for CIFS UNIX major and minor. */
> #define CIFS_UNIX_MAJOR_VERSION 1
>@@ -1894,16 +1907,20 @@ typedef struct {
> #define CIFS_UNIX_POSIX_PATHNAMES_CAP   0x00000010 /* Allow POSIX path chars  */
> #define CIFS_UNIX_POSIX_PATH_OPS_CAP    0x00000020 /* Allow new POSIX path based
> 						      calls including posix open
>-						      and posix unlink */ 
>+						      and posix unlink */
>+#define CIFS_UNIX_LARGE_READ_CAP        0x00000040 /* support reads >128K (up
>+						      to 0xFFFF00 */
>+#define CIFS_UNIX_LARGE_WRITE_CAP       0x00000080
>+
> #ifdef CONFIG_CIFS_POSIX
> /* Can not set pathnames cap yet until we send new posix create SMB since
>    otherwise server can treat such handles opened with older ntcreatex
>    (by a new client which knows how to send posix path ops)
>    as non-posix handles (can affect write behavior with byte range locks.
>    We can add back in POSIX_PATH_OPS cap when Posix Create/Mkdir finished */
>-/* #define CIFS_UNIX_CAP_MASK              0x0000003b */
>-#define CIFS_UNIX_CAP_MASK              0x0000001b 
>-#else 
>+/* #define CIFS_UNIX_CAP_MASK              0x000000fb */
>+#define CIFS_UNIX_CAP_MASK              0x000000db
>+#else
> #define CIFS_UNIX_CAP_MASK              0x00000013
> #endif /* CONFIG_CIFS_POSIX */
> 
>@@ -1913,10 +1930,10 @@ typedef struct {
> typedef struct {
> 	/* For undefined recommended transfer size return -1 in that field */
> 	__le32 OptimalTransferSize;  /* bsize on some os, iosize on other os */
>-	__le32 BlockSize; 
>+	__le32 BlockSize;
>     /* The next three fields are in terms of the block size.
> 	(above). If block size is unknown, 4096 would be a
>-	reasonable block size for a server to report. 
>+	reasonable block size for a server to report.
> 	Note that returning the blocks/blocksavail removes need
> 	to make a second call (to QFSInfo level 0x103 to get this info.
> 	UserBlockAvail is typically less than or equal to BlocksAvail,
>@@ -2071,9 +2088,9 @@ struct file_alt_name_info {
> 
> struct file_stream_info {
> 	__le32 number_of_streams;  /* BB check sizes and verify location */
>-	/* followed by info on streams themselves 
>+	/* followed by info on streams themselves
> 		u64 size;
>-		u64 allocation_size 
>+		u64 allocation_size
> 		stream info */
> };      /* level 0x109 */
> 
>@@ -2092,7 +2109,7 @@ struct cifs_posix_ace { /* access control entry (ACE) */
> 	__u8  cifs_e_tag;
> 	__u8  cifs_e_perm;
> 	__le64 cifs_uid; /* or gid */
>-} __attribute__((packed)); 
>+} __attribute__((packed));
> 
> struct cifs_posix_acl { /* access conrol list  (ACL) */
> 	__le16	version;
>@@ -2118,22 +2135,46 @@ struct cifs_posix_acl { /* access conrol list  (ACL) */
> 
> /* end of POSIX ACL definitions */
> 
>+/* POSIX Open Flags */
>+#define SMB_O_RDONLY 	 0x1
>+#define SMB_O_WRONLY 	0x2
>+#define SMB_O_RDWR 	0x4
>+#define SMB_O_CREAT 	0x10
>+#define SMB_O_EXCL 	0x20
>+#define SMB_O_TRUNC 	0x40
>+#define SMB_O_APPEND 	0x80
>+#define SMB_O_SYNC 	0x100
>+#define SMB_O_DIRECTORY 0x200
>+#define SMB_O_NOFOLLOW 	0x400
>+#define SMB_O_DIRECT 	0x800
>+
> typedef struct {
>-	__u32 OpenFlags; /* same as NT CreateX */
>-	__u32 PosixOpenFlags;
>-	__u32 Mode;
>-	__u16 Level; /* reply level requested (see QPathInfo levels) */
>-	__u16 Pad;  /* reserved - MBZ */
>+	__le32 OpenFlags; /* same as NT CreateX */
>+	__le32 PosixOpenFlags;
>+	__le64 Permissions;
>+	__le16 Level; /* reply level requested (see QPathInfo levels) */
> } __attribute__((packed)) OPEN_PSX_REQ; /* level 0x209 SetPathInfo data */
> 
> typedef struct {
>-	/* reply varies based on requested level */
>+	__le16 OplockFlags;
>+	__u16 Fid;
>+	__le32 CreateAction;
>+	__le16 ReturnedLevel;
>+	__le16 Pad;
>+	/* struct following varies based on requested level */
> } __attribute__((packed)) OPEN_PSX_RSP; /* level 0x209 SetPathInfo data */
> 
>+#define SMB_POSIX_UNLINK_FILE_TARGET		0
>+#define SMB_POSIX_UNLINK_DIRECTORY_TARGET	1
>+
>+struct unlink_psx_rq { /* level 0x20a SetPathInfo */
>+	__le16 type;
>+} __attribute__((packed));
> 
> struct file_internal_info {
> 	__u64  UniqueId; /* inode number */
> } __attribute__((packed));      /* level 0x3ee */
>+
> struct file_mode_info {
> 	__le32	Mode;
> } __attribute__((packed));      /* level 0x3f8 */
>@@ -2145,7 +2186,7 @@ struct file_attrib_tag {
> 
> 
> /********************************************************/
>-/*  FindFirst/FindNext transact2 data buffer formats    */ 
>+/*  FindFirst/FindNext transact2 data buffer formats    */
> /********************************************************/
> 
> typedef struct {
>@@ -2223,7 +2264,7 @@ typedef struct {
> 	__le64 EndOfFile;
> 	__le64 AllocationSize;
> 	__le32 ExtFileAttributes;
>-	__le32 FileNameLength; 
>+	__le32 FileNameLength;
> 	__le32 EaSize; /* length of the xattrs */
> 	__u8   ShortNameLength;
> 	__u8   Reserved;
>@@ -2250,7 +2291,7 @@ typedef struct {
> struct win_dev {
> 	unsigned char type[8]; /* IntxCHR or IntxBLK */
> 	__le64 major;
>-	__le64 minor;	
>+	__le64 minor;
> } __attribute__((packed));
> 
> struct gea {
>@@ -2282,36 +2323,36 @@ struct fealist {
> struct data_blob {
> 	__u8 *data;
> 	size_t length;
>-	void (*free) (struct data_blob * data_blob);
>+	void (*free) (struct data_blob *data_blob);
> } __attribute__((packed));
> 
> 
> #ifdef CONFIG_CIFS_POSIX
>-/* 
>+/*
> 	For better POSIX semantics from Linux client, (even better
> 	than the existing CIFS Unix Extensions) we need updated PDUs for:
>-	
>+
> 	1) PosixCreateX - to set and return the mode, inode#, device info and
> 	perhaps add a CreateDevice - to create Pipes and other special .inodes
> 	Also note POSIX open flags
>-	2) Close - to return the last write time to do cache across close 
>+	2) Close - to return the last write time to do cache across close
> 		more safely
>-	3) FindFirst return unique inode number - what about resume key, two 
>+	3) FindFirst return unique inode number - what about resume key, two
> 	forms short (matches readdir) and full (enough info to cache inodes)
> 	4) Mkdir - set mode
>-	
>-	And under consideration: 
>+
>+	And under consideration:
> 	5) FindClose2 (return nanosecond timestamp ??)
>-	6) Use nanosecond timestamps throughout all time fields if 
>+	6) Use nanosecond timestamps throughout all time fields if
> 	   corresponding attribute flag is set
> 	7) sendfile - handle based copy
> 	8) Direct i/o
> 	9) Misc fcntls?
>-	
>+
> 	what about fixing 64 bit alignment
>-	
>+
> 	There are also various legacy SMB/CIFS requests used as is
>-	
>+
> 	From existing Lanman and NTLM dialects:
> 	--------------------------------------
> 	NEGOTIATE
>@@ -2332,48 +2373,48 @@ struct data_blob {
> 		(BB verify that never need to set allocation size)
> 		SMB_SET_FILE_BASIC_INFO2 (setting times - BB can it be done via
> 			 Unix ext?)
>-	
>+
> 	COPY (note support for copy across directories) - FUTURE, OPTIONAL
> 	setting/getting OS/2 EAs - FUTURE (BB can this handle
> 	setting Linux xattrs perfectly)         - OPTIONAL
> 	dnotify                                 - FUTURE, OPTIONAL
> 	quota                                   - FUTURE, OPTIONAL
>-			
>-	Note that various requests implemented for NT interop such as 
>+
>+	Note that various requests implemented for NT interop such as
> 		NT_TRANSACT (IOCTL) QueryReparseInfo
> 	are unneeded to servers compliant with the CIFS POSIX extensions
>-	
>+
> 	From CIFS Unix Extensions:
> 	-------------------------
> 	T2 SET_PATH_INFO (SMB_SET_FILE_UNIX_LINK) for symlinks
> 	T2 SET_PATH_INFO (SMB_SET_FILE_BASIC_INFO2)
> 	T2 QUERY_PATH_INFO (SMB_QUERY_FILE_UNIX_LINK)
>-	T2 QUERY_PATH_INFO (SMB_QUERY_FILE_UNIX_BASIC) - BB check for missing inode fields
>-					Actually need QUERY_FILE_UNIX_INFO since has inode num
>-					BB what about a) blksize/blkbits/blocks
>+	T2 QUERY_PATH_INFO (SMB_QUERY_FILE_UNIX_BASIC)	BB check for missing
>+							inode fields
>+				Actually a need QUERY_FILE_UNIX_INFO
>+				since has inode num
>+				BB what about a) blksize/blkbits/blocks
> 							  b) i_version
> 							  c) i_rdev
> 							  d) notify mask?
> 							  e) generation
> 							  f) size_seqcount
> 	T2 FIND_FIRST/FIND_NEXT FIND_FILE_UNIX
>-	TRANS2_GET_DFS_REFERRAL			  - OPTIONAL but recommended
>+	TRANS2_GET_DFS_REFERRAL		      - OPTIONAL but recommended
> 	T2_QFS_INFO QueryDevice/AttributeInfo - OPTIONAL
>-	
>-	
>  */
> 
> /* xsymlink is a symlink format (used by MacOS) that can be used
>-   to save symlink info in a regular file when 
>+   to save symlink info in a regular file when
>    mounted to operating systems that do not
>    support the cifs Unix extensions or EAs (for xattr
>    based symlinks).  For such a file to be recognized
>-   as containing symlink data: 
>+   as containing symlink data:
> 
>-   1) file size must be 1067, 
>+   1) file size must be 1067,
>    2) signature must begin file data,
>    3) length field must be set to ASCII representation
>-	of a number which is less than or equal to 1024, 
>+	of a number which is less than or equal to 1024,
>    4) md5 must match that of the path data */
> 
> struct xsymlink {
>@@ -2384,10 +2425,10 @@ struct xsymlink {
> 	char length[4];
> 	char cr1;         /* \n */
> /* md5 of valid subset of path ie path[0] through path[length-1] */
>-	__u8 md5[32];    
>+	__u8 md5[32];
> 	char cr2;        /* \n */
> /* if room left, then end with \n then 0x20s by convention but not required */
>-	char path[1024];  
>+	char path[1024];
> } __attribute__((packed));
> 
> typedef struct file_xattr_info {
>@@ -2396,7 +2437,8 @@ typedef struct file_xattr_info {
> 	__u32 xattr_value_len;
> 	char  xattr_name[0];
> 	/* followed by xattr_value[xattr_value_len], no pad */
>-} __attribute__((packed)) FILE_XATTR_INFO; /* extended attribute, info level 0x205 */
>+} __attribute__((packed)) FILE_XATTR_INFO; /* extended attribute info
>+					      level 0x205 */
> 
> 
> /* flags for chattr command */
>@@ -2422,8 +2464,9 @@ typedef struct file_xattr_info {
> typedef struct file_chattr_info {
> 	__le64	mask; /* list of all possible attribute bits */
> 	__le64	mode; /* list of actual attribute bits on this inode */
>-} __attribute__((packed)) FILE_CHATTR_INFO;  /* ext attributes (chattr, chflags) level 0x206 */
>+} __attribute__((packed)) FILE_CHATTR_INFO;  /* ext attributes
>+						(chattr, chflags) level 0x206 */
> 
>-#endif 
>+#endif
> 
> #endif				/* _CIFSPDU_H */
>diff --git a/fs/cifs/cifsproto.h b/fs/cifs/cifsproto.h
>index ae79d24..4a50e29 100644
>--- a/fs/cifs/cifsproto.h
>+++ b/fs/cifs/cifsproto.h
>@@ -1,7 +1,7 @@
> /*
>  *   fs/cifs/cifsproto.h
>  *
>- *   Copyright (c) International Business Machines  Corp., 2002,2006
>+ *   Copyright (c) International Business Machines  Corp., 2002,2007
>  *   Author(s): Steve French (sfrench@us.ibm.com)
>  *
>  *   This library is free software; you can redistribute it and/or modify
>@@ -16,7 +16,7 @@
>  *
>  *   You should have received a copy of the GNU Lesser General Public License
>  *   along with this library; if not, write to the Free Software
>- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
>+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>  */
> #ifndef _CIFSPROTO_H
> #define _CIFSPROTO_H
>@@ -24,6 +24,7 @@
> #include <linux/version.h>
> 
> struct statfs;
>+struct smb_vol;
> 
> #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,8)
> #define kvec iovec
>@@ -61,13 +62,13 @@ extern int SendReceive(const unsigned int /* xid */ , struct cifsSesInfo *,
> 			struct smb_hdr * /* out */ ,
> 			int * /* bytes returned */ , const int long_op);
> extern int SendReceive2(const unsigned int /* xid */ , struct cifsSesInfo *,
>-			struct kvec *, int /* nvec to send */, 
>+			struct kvec *, int /* nvec to send */,
> 			int * /* type of buf returned */ , const int long_op);
>-extern int SendReceiveBlockingLock(const unsigned int /* xid */ , struct cifsTconInfo *,
>+extern int SendReceiveBlockingLock(const unsigned int /* xid */ ,
>+					struct cifsTconInfo *,
> 				struct smb_hdr * /* input */ ,
> 				struct smb_hdr * /* out */ ,
> 				int * /* bytes returned */);
>-extern int checkSMBhdr(struct smb_hdr *smb, __u16 mid);
> extern int checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length);
> extern int is_valid_oplock_break(struct smb_hdr *smb, struct TCP_Server_Info *);
> extern int is_size_safe_to_change(struct cifsInodeInfo *, __u64 eof);
>@@ -76,19 +77,19 @@ extern unsigned int smbCalcSize(struct smb_hdr *ptr);
> extern unsigned int smbCalcSize_LE(struct smb_hdr *ptr);
> extern int decode_negTokenInit(unsigned char *security_blob, int length,
> 			enum securityEnum *secType);
>-extern int cifs_inet_pton(int, char * source, void *dst);
>+extern int cifs_inet_pton(int, char *source, void *dst);
> extern int map_smb_to_linux_error(struct smb_hdr *smb);
> extern void header_assemble(struct smb_hdr *, char /* command */ ,
> 			    const struct cifsTconInfo *, int /* length of
> 			    fixed section (word count) in two byte units */);
> extern int small_smb_init_no_tc(const int smb_cmd, const int wct,
> 				struct cifsSesInfo *ses,
>-				void ** request_buf);
>+				void **request_buf);
> extern int CIFS_SessSetup(unsigned int xid, struct cifsSesInfo *ses,
>-			     const int stage, 
>+			     const int stage,
> 			     const struct nls_table *nls_cp);
> extern __u16 GetNextMid(struct TCP_Server_Info *server);
>-extern struct oplock_q_entry * AllocOplockQEntry(struct inode *, u16, 
>+extern struct oplock_q_entry *AllocOplockQEntry(struct inode *, u16,
> 						 struct cifsTconInfo *);
> extern void DeleteOplockQEntry(struct oplock_q_entry *);
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
>@@ -103,12 +104,12 @@ extern time_t cnvrtDosUnixTm(__u16 date, __u16 time);
> extern __le64 cnvrtDosCifsTm(__u16 date, __u16 time);
> 
> extern int cifs_get_inode_info(struct inode **pinode,
>-			const unsigned char *search_path, 
>+			const unsigned char *search_path,
> 			FILE_ALL_INFO * pfile_info,
> 			struct super_block *sb, int xid);
> extern int cifs_get_inode_info_unix(struct inode **pinode,
> 			const unsigned char *search_path,
>-			struct super_block *sb,int xid);
>+			struct super_block *sb, int xid);
> 
> extern int cifs_mount(struct super_block *, struct cifs_sb_info *, char *,
> 			const char *);
>@@ -116,8 +117,8 @@ extern int cifs_umount(struct super_block *, struct cifs_sb_info *);
> void cifs_proc_init(void);
> void cifs_proc_clean(void);
> 
>-extern int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo, 
>-			struct nls_table * nls_info);
>+extern int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
>+			struct nls_table *nls_info);
> extern int CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses);
> 
> extern int CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
>@@ -126,11 +127,11 @@ extern int CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
> 
> extern int CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
> 		const char *searchName, const struct nls_table *nls_codepage,
>-		__u16 *searchHandle, struct cifs_search_info * psrch_inf, 
>+		__u16 *searchHandle, struct cifs_search_info *psrch_inf,
> 		int map, const char dirsep);
> 
> extern int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
>-		__u16 searchHandle, struct cifs_search_info * psrch_inf);
>+		__u16 searchHandle, struct cifs_search_info *psrch_inf);
> 
> extern int CIFSFindClose(const int, struct cifsTconInfo *tcon,
> 			const __u16 search_handle);
>@@ -141,9 +142,9 @@ extern int CIFSSMBQPathInfo(const int xid, struct cifsTconInfo *tcon,
> 			int legacy /* whether to use old info level */,
> 			const struct nls_table *nls_codepage, int remap);
> extern int SMBQueryInformation(const int xid, struct cifsTconInfo *tcon,
>-                        const unsigned char *searchName,
>-                        FILE_ALL_INFO * findData,
>-                        const struct nls_table *nls_codepage, int remap);
>+			const unsigned char *searchName,
>+			FILE_ALL_INFO *findData,
>+			const struct nls_table *nls_codepage, int remap);
> 
> extern int CIFSSMBUnixQPathInfo(const int xid,
> 			struct cifsTconInfo *tcon,
>@@ -161,11 +162,13 @@ extern int connect_to_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
> 			const char *old_path,
> 			const struct nls_table *nls_codepage, int remap);
> extern int get_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
>-			const char *old_path, 
>+			const char *old_path,
> 			const struct nls_table *nls_codepage,
>-			unsigned int *pnum_referrals, 
>-			unsigned char ** preferrals,
>+			unsigned int *pnum_referrals,
>+			unsigned char **preferrals,
> 			int remap);
>+extern void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
>+				 struct super_block *sb, struct smb_vol *vol);
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
> extern int CIFSSMBQFSInfo(const int xid, struct cifsTconInfo *tcon,
> 			struct kstatfs *FSData);
>@@ -208,11 +211,11 @@ extern int CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon,
> 			const struct nls_table *nls_codepage,
> 			int remap_special_chars);
> extern int CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon,
>-			 __u64 size, __u16 fileHandle,__u32 opener_pid, 
>+			 __u64 size, __u16 fileHandle, __u32 opener_pid,
> 			int AllocSizeFlag);
> extern int CIFSSMBUnixSetPerms(const int xid, struct cifsTconInfo *pTcon,
> 			char *full_path, __u64 mode, __u64 uid,
>-			__u64 gid, dev_t dev, 
>+			__u64 gid, dev_t dev,
> 			const struct nls_table *nls_codepage,
> 			int remap_special_chars);
> 
>@@ -223,7 +226,10 @@ extern int CIFSSMBMkDir(const int xid, struct cifsTconInfo *tcon,
> extern int CIFSSMBRmDir(const int xid, struct cifsTconInfo *tcon,
> 			const char *name, const struct nls_table *nls_codepage,
> 			int remap_special_chars);
>-
>+extern int CIFSPOSIXDelFile(const int xid, struct cifsTconInfo *tcon,
>+			const char *name, __u16 type,
>+			const struct nls_table *nls_codepage,
>+			int remap_special_chars);
> extern int CIFSSMBDelFile(const int xid, struct cifsTconInfo *tcon,
> 			const char *name,
> 			const struct nls_table *nls_codepage,
>@@ -232,8 +238,8 @@ extern int CIFSSMBRename(const int xid, struct cifsTconInfo *tcon,
> 			const char *fromName, const char *toName,
> 			const struct nls_table *nls_codepage,
> 			int remap_special_chars);
>-extern int CIFSSMBRenameOpenFile(const int xid,struct cifsTconInfo *pTcon,
>-			int netfid, char * target_name, 
>+extern int CIFSSMBRenameOpenFile(const int xid, struct cifsTconInfo *pTcon,
>+			int netfid, char *target_name,
> 			const struct nls_table *nls_codepage,
> 			int remap_special_chars);
> extern int CIFSCreateHardLink(const int xid,
>@@ -244,7 +250,7 @@ extern int CIFSCreateHardLink(const int xid,
> extern int CIFSUnixCreateHardLink(const int xid,
> 			struct cifsTconInfo *tcon,
> 			const char *fromName, const char *toName,
>-			const struct nls_table *nls_codepage, 
>+			const struct nls_table *nls_codepage,
> 			int remap_special_chars);
> extern int CIFSUnixCreateSymLink(const int xid,
> 			struct cifsTconInfo *tcon,
>@@ -255,7 +261,7 @@ extern int CIFSSMBUnixQuerySymLink(const int xid,
> 			const unsigned char *searchName,
> 			char *syminfo, const int buflen,
> 			const struct nls_table *nls_codepage);
>-extern int CIFSSMBQueryReparseLinkInfo(const int xid, 
>+extern int CIFSSMBQueryReparseLinkInfo(const int xid,
> 			struct cifsTconInfo *tcon,
> 			const unsigned char *searchName,
> 			char *symlinkinfo, const int buflen, __u16 fid,
>@@ -271,30 +277,35 @@ extern int SMBLegacyOpen(const int xid, struct cifsTconInfo *tcon,
> 			const int access_flags, const int omode,
> 			__u16 * netfid, int *pOplock, FILE_ALL_INFO *,
> 			const struct nls_table *nls_codepage, int remap);
>+extern int CIFSPOSIXCreate(const int xid, struct cifsTconInfo *tcon,
>+			u32 posix_flags, __u64 mode, __u16 * netfid,
>+			FILE_UNIX_BASIC_INFO *pRetData,
>+			__u32 *pOplock, const char *name,
>+			const struct nls_table *nls_codepage, int remap);
> extern int CIFSSMBClose(const int xid, struct cifsTconInfo *tcon,
> 			const int smb_file_id);
> 
> extern int CIFSSMBRead(const int xid, struct cifsTconInfo *tcon,
>-                        const int netfid, unsigned int count,
>-                        const __u64 lseek, unsigned int *nbytes, char **buf,
>-			int * return_buf_type);
>+			const int netfid, unsigned int count,
>+			const __u64 lseek, unsigned int *nbytes, char **buf,
>+			int *return_buf_type);
> extern int CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
> 			const int netfid, const unsigned int count,
> 			const __u64 lseek, unsigned int *nbytes,
>-			const char *buf, const char __user *ubuf, 
>+			const char *buf, const char __user *ubuf,
> 			const int long_op);
> extern int CIFSSMBWrite2(const int xid, struct cifsTconInfo *tcon,
> 			const int netfid, const unsigned int count,
>-			const __u64 offset, unsigned int *nbytes, 
>+			const __u64 offset, unsigned int *nbytes,
> 			struct kvec *iov, const int nvec, const int long_op);
> extern int CIFSGetSrvInodeNumber(const int xid, struct cifsTconInfo *tcon,
> 			const unsigned char *searchName, __u64 * inode_number,
>-			const struct nls_table *nls_codepage, 
>+			const struct nls_table *nls_codepage,
> 			int remap_special_chars);
> extern int cifs_convertUCSpath(char *target, const __le16 *source, int maxlen,
>-			const struct nls_table * codepage);
>-extern int cifsConvertToUCS(__le16 * target, const char *source, int maxlen,
>-			const struct nls_table * cp, int mapChars);
>+			const struct nls_table *codepage);
>+extern int cifsConvertToUCS(__le16 *target, const char *source, int maxlen,
>+			const struct nls_table *cp, int mapChars);
> 
> extern int CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
> 			const __u16 netfid, const __u64 len,
>@@ -303,7 +314,7 @@ extern int CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
> 			const int waitFlag);
> extern int CIFSSMBPosixLock(const int xid, struct cifsTconInfo *tcon,
> 			const __u16 smb_file_id, const int get_flag,
>-			const __u64 len, struct file_lock *, 
>+			const __u64 len, struct file_lock *,
> 			const __u16 lock_type, const int waitFlag);
> extern int CIFSSMBTDis(const int xid, struct cifsTconInfo *tcon);
> extern int CIFSSMBLogoff(const int xid, struct cifsSesInfo *ses);
>@@ -313,58 +324,58 @@ extern void sesInfoFree(struct cifsSesInfo *);
> extern struct cifsTconInfo *tconInfoAlloc(void);
> extern void tconInfoFree(struct cifsTconInfo *);
> 
>-extern int cifs_reconnect(struct TCP_Server_Info *server);
>-
>-extern int cifs_sign_smb(struct smb_hdr *, struct TCP_Server_Info *,__u32 *);
>+extern int cifs_sign_smb(struct smb_hdr *, struct TCP_Server_Info *, __u32 *);
> extern int cifs_sign_smb2(struct kvec *iov, int n_vec, struct TCP_Server_Info *,
> 			  __u32 *);
>-extern int cifs_verify_signature(struct smb_hdr *, const char * mac_key,
>-	__u32 expected_sequence_number);
>-extern int cifs_calculate_mac_key(char * key,const char * rn,const char * pass);
>-extern int CalcNTLMv2_partial_mac_key(struct cifsSesInfo *, 
>+extern int cifs_verify_signature(struct smb_hdr *,
>+				 const struct mac_key *mac_key,
>+				__u32 expected_sequence_number);
>+extern int cifs_calculate_mac_key(struct mac_key *key, const char *rn,
>+				 const char *pass);
>+extern int CalcNTLMv2_partial_mac_key(struct cifsSesInfo *,
> 			const struct nls_table *);
>-extern void CalcNTLMv2_response(const struct cifsSesInfo *, char * );
>-extern void setup_ntlmv2_rsp(struct cifsSesInfo *, char *, 
>+extern void CalcNTLMv2_response(const struct cifsSesInfo *, char *);
>+extern void setup_ntlmv2_rsp(struct cifsSesInfo *, char *,
> 			     const struct nls_table *);
> #ifdef CONFIG_CIFS_WEAK_PW_HASH
>-extern void calc_lanman_hash(struct cifsSesInfo * ses, char * lnm_session_key);
>+extern void calc_lanman_hash(struct cifsSesInfo *ses, char *lnm_session_key);
> #endif /* CIFS_WEAK_PW_HASH */
> extern int CIFSSMBCopy(int xid,
> 			struct cifsTconInfo *source_tcon,
> 			const char *fromName,
> 			const __u16 target_tid,
> 			const char *toName, const int flags,
>-			const struct nls_table *nls_codepage, 
>+			const struct nls_table *nls_codepage,
> 			int remap_special_chars);
>-extern int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon, 
>-			const int notify_subdirs,const __u16 netfid,
>-			__u32 filter, struct file * file, int multishot, 
>+extern int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon,
>+			const int notify_subdirs, const __u16 netfid,
>+			__u32 filter, struct file *file, int multishot,
> 			const struct nls_table *nls_codepage);
> extern ssize_t CIFSSMBQAllEAs(const int xid, struct cifsTconInfo *tcon,
>-			const unsigned char *searchName, char * EAData,
>+			const unsigned char *searchName, char *EAData,
> 			size_t bufsize, const struct nls_table *nls_codepage,
> 			int remap_special_chars);
>-extern ssize_t CIFSSMBQueryEA(const int xid,struct cifsTconInfo * tcon,
>-		const unsigned char * searchName,const unsigned char * ea_name,
>-		unsigned char * ea_value, size_t buf_size, 
>+extern ssize_t CIFSSMBQueryEA(const int xid, struct cifsTconInfo *tcon,
>+		const unsigned char *searchName, const unsigned char *ea_name,
>+		unsigned char *ea_value, size_t buf_size,
> 		const struct nls_table *nls_codepage, int remap_special_chars);
>-extern int CIFSSMBSetEA(const int xid, struct cifsTconInfo *tcon, 
>-		const char *fileName, const char * ea_name, 
>-		const void * ea_value, const __u16 ea_value_len, 
>+extern int CIFSSMBSetEA(const int xid, struct cifsTconInfo *tcon,
>+		const char *fileName, const char *ea_name,
>+		const void *ea_value, const __u16 ea_value_len,
> 		const struct nls_table *nls_codepage, int remap_special_chars);
> extern int CIFSSMBGetCIFSACL(const int xid, struct cifsTconInfo *tcon,
> 			__u16 fid, char *acl_inf, const int buflen,
> 			const int acl_type /* ACCESS vs. DEFAULT */);
> extern int CIFSSMBGetPosixACL(const int xid, struct cifsTconInfo *tcon,
> 		const unsigned char *searchName,
>-		char *acl_inf, const int buflen,const int acl_type,
>+		char *acl_inf, const int buflen, const int acl_type,
> 		const struct nls_table *nls_codepage, int remap_special_chars);
> extern int CIFSSMBSetPosixACL(const int xid, struct cifsTconInfo *tcon,
> 		const unsigned char *fileName,
> 		const char *local_acl, const int buflen, const int acl_type,
> 		const struct nls_table *nls_codepage, int remap_special_chars);
> extern int CIFSGetExtAttr(const int xid, struct cifsTconInfo *tcon,
>-                const int netfid, __u64 * pExtAttrBits, __u64 *pMask);
>+			const int netfid, __u64 * pExtAttrBits, __u64 *pMask);
> #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 16)
> extern void * kzalloc(size_t size, unsigned flgs);
> #endif
>diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
>index b50718e..2a805fa 100644
>--- a/fs/cifs/cifssmb.c
>+++ b/fs/cifs/cifssmb.c
>@@ -1,7 +1,7 @@
> /*
>  *   fs/cifs/cifssmb.c
>  *
>- *   Copyright (C) International Business Machines  Corp., 2002,2006
>+ *   Copyright (C) International Business Machines  Corp., 2002,2007
>  *   Author(s): Steve French (sfrench@us.ibm.com)
>  *
>  *   Contains the routines for constructing the SMB PDUs themselves
>@@ -24,8 +24,8 @@
>  /* SMB/CIFS PDU handling routines here - except for leftovers in connect.c   */
>  /* These are mostly routines that operate on a pathname, or on a tree id     */
>  /* (mounted volume), but there are eight handle based routines which must be */
>- /* treated slightly different for reconnection purposes since we never want  */
>- /* to reuse a stale file handle and the caller knows the file handle */
>+ /* treated slightly differently for reconnection purposes since we never     */
>+ /* want to reuse a stale file handle and only the caller knows the file info */
> 
> #include <linux/fs.h>
> #include <linux/kernel.h>
>@@ -51,7 +51,7 @@ static struct {
> 	{LANMAN_PROT, "\2LM1.2X002"},
> 	{LANMAN2_PROT, "\2LANMAN2.1"},
> #endif /* weak password hashing for legacy clients */
>-	{CIFS_PROT, "\2NT LM 0.12"}, 
>+	{CIFS_PROT, "\2NT LM 0.12"},
> 	{POSIX_PROT, "\2POSIX 2"},
> 	{BAD_PROT, "\2"}
> };
>@@ -64,7 +64,7 @@ static struct {
> 	{LANMAN_PROT, "\2LM1.2X002"},
> 	{LANMAN2_PROT, "\2LANMAN2.1"},
> #endif /* weak password hashing for legacy clients */
>-	{CIFS_PROT, "\2NT LM 0.12"}, 
>+	{CIFS_PROT, "\2NT LM 0.12"},
> 	{BAD_PROT, "\2"}
> };
> #endif
>@@ -87,19 +87,18 @@ static struct {
> 
> /* Mark as invalid, all open files on tree connections since they
>    were closed when session to server was lost */
>-static void mark_open_files_invalid(struct cifsTconInfo * pTcon)
>+static void mark_open_files_invalid(struct cifsTconInfo *pTcon)
> {
> 	struct cifsFileInfo *open_file = NULL;
>-	struct list_head * tmp;
>-	struct list_head * tmp1;
>+	struct list_head *tmp;
>+	struct list_head *tmp1;
> 
> /* list all files open on tree connection and mark them invalid */
> 	write_lock(&GlobalSMBSeslock);
> 	list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
>-		open_file = list_entry(tmp,struct cifsFileInfo, tlist);
>-		if(open_file) {
>+		open_file = list_entry(tmp, struct cifsFileInfo, tlist);
>+		if (open_file)
> 			open_file->invalidHandle = TRUE;
>-		}
> 	}
> 	write_unlock(&GlobalSMBSeslock);
> 	/* BB Add call to invalidate_inodes(sb) for all superblocks mounted
>@@ -116,23 +115,23 @@ small_smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
> 	/* SMBs NegProt, SessSetup, uLogoff do not have tcon yet so
> 	   check for tcp and smb session status done differently
> 	   for those three - in the calling routine */
>-	if(tcon) {
>-		if(tcon->tidStatus == CifsExiting) {
>+	if (tcon) {
>+		if (tcon->tidStatus == CifsExiting) {
> 			/* only tree disconnect, open, and write,
> 			(and ulogoff which does not have tcon)
> 			are allowed as we start force umount */
>-			if((smb_command != SMB_COM_WRITE_ANDX) && 
>-			   (smb_command != SMB_COM_OPEN_ANDX) && 
>+			if ((smb_command != SMB_COM_WRITE_ANDX) &&
>+			   (smb_command != SMB_COM_OPEN_ANDX) &&
> 			   (smb_command != SMB_COM_TREE_DISCONNECT)) {
>-				cFYI(1,("can not send cmd %d while umounting",
>+				cFYI(1, ("can not send cmd %d while umounting",
> 					smb_command));
> 				return -ENODEV;
> 			}
> 		}
>-		if((tcon->ses) && (tcon->ses->status != CifsExiting) &&
>-				  (tcon->ses->server)){
>+		if ((tcon->ses) && (tcon->ses->status != CifsExiting) &&
>+				  (tcon->ses->server)) {
> 			struct nls_table *nls_codepage;
>-				/* Give Demultiplex thread up to 10 seconds to 
>+				/* Give Demultiplex thread up to 10 seconds to
> 				   reconnect, should be greater than cifs socket
> 				   timeout which is 7 seconds */
> 			while(tcon->ses->server->tcpStatus == CifsNeedReconnect) {
>@@ -145,52 +144,56 @@ small_smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
> 						timeout);
> 				}
> #else
>-				wait_event_interruptible_timeout(
>-					tcon->ses->server->response_q,
>-					(tcon->ses->server->tcpStatus == CifsGood),
>-					10 * HZ);
>+				wait_event_interruptible_timeout(tcon->ses->server->response_q,
>+					(tcon->ses->server->tcpStatus == CifsGood), 10 * HZ);
> #endif
>-				if(tcon->ses->server->tcpStatus == CifsNeedReconnect) {
>+				if (tcon->ses->server->tcpStatus == CifsNeedReconnect) {
> 					/* on "soft" mounts we wait once */
>-					if((tcon->retry == FALSE) || 
>+					if ((tcon->retry == FALSE) ||
> 					   (tcon->ses->status == CifsExiting)) {
>-						cFYI(1,("gave up waiting on reconnect in smb_init"));
>+						cFYI(1, ("gave up waiting on "
>+						      "reconnect in smb_init"));
> 						return -EHOSTDOWN;
> 					} /* else "hard" mount - keep retrying
> 					     until process is killed or server
> 					     comes back on-line */
> 				} else /* TCP session is reestablished now */
> 					break;
>-				 
> 			}
>-			
>+
> 			nls_codepage = load_nls_default();
> 		/* need to prevent multiple threads trying to
> 		simultaneously reconnect the same SMB session */
> 			down(&tcon->ses->sesSem);
>-			if(tcon->ses->status == CifsNeedReconnect)
>-				rc = cifs_setup_session(0, tcon->ses, 
>+			if (tcon->ses->status == CifsNeedReconnect)
>+				rc = cifs_setup_session(0, tcon->ses,
> 							nls_codepage);
>-			if(!rc && (tcon->tidStatus == CifsNeedReconnect)) {
>+			if (!rc && (tcon->tidStatus == CifsNeedReconnect)) {
> 				mark_open_files_invalid(tcon);
>-				rc = CIFSTCon(0, tcon->ses, tcon->treeName, tcon
>-					, nls_codepage);
>+				rc = CIFSTCon(0, tcon->ses, tcon->treeName,
>+					      tcon, nls_codepage);
> 				up(&tcon->ses->sesSem);
>+				/* tell server which Unix caps we support */
>+				if (tcon->ses->capabilities & CAP_UNIX)
>+					reset_cifs_unix_caps(0 /* no xid */,
>+						tcon,
>+						NULL /* we do not know sb */,
>+						NULL /* no vol info */);
> 				/* BB FIXME add code to check if wsize needs
> 				   update due to negotiated smb buffer size
> 				   shrinking */
>-				if(rc == 0)
>+				if (rc == 0)
> 					atomic_inc(&tconInfoReconnectCount);
> 
> 				cFYI(1, ("reconnect tcon rc = %d", rc));
>-				/* Removed call to reopen open files here - 
>-				   it is safer (and faster) to reopen files
>+				/* Removed call to reopen open files here.
>+				   It is safer (and faster) to reopen files
> 				   one at a time as needed in read and write */
> 
>-				/* Check if handle based operation so we 
>+				/* Check if handle based operation so we
> 				   know whether we can continue or not without
> 				   returning to caller to reset file handle */
>-				switch(smb_command) {
>+				switch (smb_command) {
> 					case SMB_COM_READ_ANDX:
> 					case SMB_COM_WRITE_ANDX:
> 					case SMB_COM_CLOSE:
>@@ -209,7 +212,7 @@ small_smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
> 			return -EIO;
> 		}
> 	}
>-	if(rc)
>+	if (rc)
> 		return rc;
> 
> 	*request_buf = cifs_small_buf_get();
>@@ -218,23 +221,24 @@ small_smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
> 		return -ENOMEM;
> 	}
> 
>-	header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,wct);
>+	header_assemble((struct smb_hdr *) *request_buf, smb_command,
>+			tcon, wct);
> 
>-        if(tcon != NULL)
>-                cifs_stats_inc(&tcon->num_smbs_sent);
>+	if (tcon != NULL)
>+		cifs_stats_inc(&tcon->num_smbs_sent);
> 
> 	return rc;
> }
> 
> int
>-small_smb_init_no_tc(const int smb_command, const int wct, 
>+small_smb_init_no_tc(const int smb_command, const int wct,
> 		     struct cifsSesInfo *ses, void **request_buf)
> {
> 	int rc;
>-	struct smb_hdr * buffer;
>+	struct smb_hdr *buffer;
> 
> 	rc = small_smb_init(smb_command, wct, NULL, request_buf);
>-	if(rc)
>+	if (rc)
> 		return rc;
> 
> 	buffer = (struct smb_hdr *)*request_buf;
>@@ -246,7 +250,7 @@ small_smb_init_no_tc(const int smb_command, const int wct,
> 
> 	/* uid, tid can stay at zero as set in header assemble */
> 
>-	/* BB add support for turning on the signing when 
>+	/* BB add support for turning on the signing when
> 	this function is used after 1st of session setup requests */
> 
> 	return rc;
>@@ -263,22 +267,22 @@ smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
> 	/* SMBs NegProt, SessSetup, uLogoff do not have tcon yet so
> 	   check for tcp and smb session status done differently
> 	   for those three - in the calling routine */
>-	if(tcon) {
>-		if(tcon->tidStatus == CifsExiting) {
>+	if (tcon) {
>+		if (tcon->tidStatus == CifsExiting) {
> 			/* only tree disconnect, open, and write,
> 			  (and ulogoff which does not have tcon)
> 			  are allowed as we start force umount */
>-			if((smb_command != SMB_COM_WRITE_ANDX) &&
>+			if ((smb_command != SMB_COM_WRITE_ANDX) &&
> 			   (smb_command != SMB_COM_OPEN_ANDX) &&
> 			   (smb_command != SMB_COM_TREE_DISCONNECT)) {
>-				cFYI(1,("can not send cmd %d while umounting",
>+				cFYI(1, ("can not send cmd %d while umounting",
> 					smb_command));
> 				return -ENODEV;
> 			}
> 		}
> 
>-		if((tcon->ses) && (tcon->ses->status != CifsExiting) && 
>-				  (tcon->ses->server)){
>+		if ((tcon->ses) && (tcon->ses->status != CifsExiting) &&
>+				  (tcon->ses->server)) {
> 			struct nls_table *nls_codepage;
> 				/* Give Demultiplex thread up to 10 seconds to
> 				   reconnect, should be greater than cifs socket
>@@ -293,53 +297,56 @@ smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
> 						 timeout);
> 				}
> #else
>-				wait_event_interruptible_timeout(
>-					tcon->ses->server->response_q,
>-					(tcon->ses->server->tcpStatus == CifsGood),
>-					10 * HZ);
>+				wait_event_interruptible_timeout(tcon->ses->server->response_q,
>+					(tcon->ses->server->tcpStatus == CifsGood), 10 * HZ);
> #endif
>-				if(tcon->ses->server->tcpStatus == 
>+				if (tcon->ses->server->tcpStatus ==
> 						CifsNeedReconnect) {
> 					/* on "soft" mounts we wait once */
>-					if((tcon->retry == FALSE) || 
>+					if ((tcon->retry == FALSE) ||
> 					   (tcon->ses->status == CifsExiting)) {
>-						cFYI(1,("gave up waiting on reconnect in smb_init"));
>+						cFYI(1, ("gave up waiting on "
>+						      "reconnect in smb_init"));
> 						return -EHOSTDOWN;
> 					} /* else "hard" mount - keep retrying
> 					     until process is killed or server
> 					     comes on-line */
> 				} else /* TCP session is reestablished now */
> 					break;
>-				 
> 			}
>-			
> 			nls_codepage = load_nls_default();
> 		/* need to prevent multiple threads trying to
> 		simultaneously reconnect the same SMB session */
> 			down(&tcon->ses->sesSem);
>-			if(tcon->ses->status == CifsNeedReconnect)
>-				rc = cifs_setup_session(0, tcon->ses, 
>+			if (tcon->ses->status == CifsNeedReconnect)
>+				rc = cifs_setup_session(0, tcon->ses,
> 							nls_codepage);
>-			if(!rc && (tcon->tidStatus == CifsNeedReconnect)) {
>+			if (!rc && (tcon->tidStatus == CifsNeedReconnect)) {
> 				mark_open_files_invalid(tcon);
> 				rc = CIFSTCon(0, tcon->ses, tcon->treeName,
> 					      tcon, nls_codepage);
> 				up(&tcon->ses->sesSem);
>+				/* tell server which Unix caps we support */
>+				if (tcon->ses->capabilities & CAP_UNIX)
>+					reset_cifs_unix_caps(0 /* no xid */,
>+						tcon,
>+						NULL /* do not know sb */,
>+						NULL /* no vol info */);
> 				/* BB FIXME add code to check if wsize needs
> 				update due to negotiated smb buffer size
> 				shrinking */
>-				if(rc == 0)
>+				if (rc == 0)
> 					atomic_inc(&tconInfoReconnectCount);
> 
> 				cFYI(1, ("reconnect tcon rc = %d", rc));
>-				/* Removed call to reopen open files here - 
>-				   it is safer (and faster) to reopen files
>+				/* Removed call to reopen open files here.
>+				   It is safer (and faster) to reopen files
> 				   one at a time as needed in read and write */
> 
>-				/* Check if handle based operation so we 
>+				/* Check if handle based operation so we
> 				   know whether we can continue or not without
> 				   returning to caller to reset file handle */
>-				switch(smb_command) {
>+				switch (smb_command) {
> 					case SMB_COM_READ_ANDX:
> 					case SMB_COM_WRITE_ANDX:
> 					case SMB_COM_CLOSE:
>@@ -358,7 +365,7 @@ smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
> 			return -EIO;
> 		}
> 	}
>-	if(rc)
>+	if (rc)
> 		return rc;
> 
> 	*request_buf = cifs_buf_get();
>@@ -370,48 +377,48 @@ smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
>     /* potential retries of smb operations it turns out we can determine */
>     /* from the mid flags when the request buffer can be resent without  */
>     /* having to use a second distinct buffer for the response */
>-	if(response_buf)
>-		*response_buf = *request_buf; 
>+	if (response_buf)
>+		*response_buf = *request_buf;
> 
> 	header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
> 			wct /*wct */ );
> 
>-        if(tcon != NULL)
>-                cifs_stats_inc(&tcon->num_smbs_sent);
>+	if (tcon != NULL)
>+		cifs_stats_inc(&tcon->num_smbs_sent);
> 
> 	return rc;
> }
> 
>-static int validate_t2(struct smb_t2_rsp * pSMB) 
>+static int validate_t2(struct smb_t2_rsp *pSMB)
> {
> 	int rc = -EINVAL;
> 	int total_size;
>-	char * pBCC;
>+	char *pBCC;
> 
> 	/* check for plausible wct, bcc and t2 data and parm sizes */
> 	/* check for parm and data offset going beyond end of smb */
>-	if(pSMB->hdr.WordCount >= 10) {
>-		if((le16_to_cpu(pSMB->t2_rsp.ParameterOffset) <= 1024) &&
>+	if (pSMB->hdr.WordCount >= 10) {
>+		if ((le16_to_cpu(pSMB->t2_rsp.ParameterOffset) <= 1024) &&
> 		   (le16_to_cpu(pSMB->t2_rsp.DataOffset) <= 1024)) {
> 			/* check that bcc is at least as big as parms + data */
> 			/* check that bcc is less than negotiated smb buffer */
> 			total_size = le16_to_cpu(pSMB->t2_rsp.ParameterCount);
>-			if(total_size < 512) {
>-				total_size+=le16_to_cpu(pSMB->t2_rsp.DataCount);
>+			if (total_size < 512) {
>+				total_size +=
>+					le16_to_cpu(pSMB->t2_rsp.DataCount);
> 				/* BCC le converted in SendReceive */
>-				pBCC = (pSMB->hdr.WordCount * 2) + 
>+				pBCC = (pSMB->hdr.WordCount * 2) +
> 					sizeof(struct smb_hdr) +
> 					(char *)pSMB;
>-				if((total_size <= (*(u16 *)pBCC)) && 
>-				   (total_size < 
>+				if ((total_size <= (*(u16 *)pBCC)) &&
>+				   (total_size <
> 					CIFSMaxBufSize+MAX_CIFS_HDR_SIZE)) {
> 					return 0;
> 				}
>-				
> 			}
> 		}
> 	}
>-	cifs_dump_mem("Invalid transact2 SMB: ",(char *)pSMB,
>+	cifs_dump_mem("Invalid transact2 SMB: ", (char *)pSMB,
> 		sizeof(struct smb_t2_rsp) + 16);
> 	return rc;
> }
>@@ -423,12 +430,12 @@ CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
> 	int rc = 0;
> 	int bytes_returned;
> 	int i;
>-	struct TCP_Server_Info * server;
>+	struct TCP_Server_Info *server;
> 	u16 count;
> 	unsigned int secFlags;
> 	u16 dialect;
> 
>-	if(ses->server)
>+	if (ses->server)
> 		server = ses->server;
> 	else {
> 		rc = -EIO;
>@@ -439,12 +446,8 @@ CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
> 	if (rc)
> 		return rc;
> 
>-#ifdef CONFIG_CIFS_DEBUG2
>-	cFYI(1, ("security flags 0x%x override flags 0x%x",
>-		extended_security, ses->overrideSecFlg)); 
>-#endif
> 	/* if any of auth flags (ie not sign or seal) are overriden use them */
>-	if(ses->overrideSecFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
>+	if (ses->overrideSecFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
> 		secFlags = ses->overrideSecFlg;  /* BB FIXME fix sign flags? */
> 	else /* if override flags set only sign/seal OR them with global auth */
> 		secFlags = extended_security | ses->overrideSecFlg;
>@@ -452,12 +455,12 @@ CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
> 	cFYI(1, ("secFlags 0x%x", secFlags));
> 
> 	pSMB->hdr.Mid = GetNextMid(server);
>-	pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
>-	if((secFlags & CIFSSEC_MUST_KRB5) == CIFSSEC_MUST_KRB5)
>+	pSMB->hdr.Flags2 |= (SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS);
>+	if ((secFlags & CIFSSEC_MUST_KRB5) == CIFSSEC_MUST_KRB5)
> 		pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
>-	
>+
> 	count = 0;
>-	for(i=0;i<CIFS_NUM_PROT;i++) {
>+	for (i = 0; i < CIFS_NUM_PROT; i++) {
> 		strncpy(pSMB->DialectsArray+count, protocols[i].name, 16);
> 		count += strlen(protocols[i].name) + 1;
> 		/* null at end of source and target buffers anyway */
>@@ -467,26 +470,26 @@ CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
> 
> 	rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
> 			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
>-	if (rc != 0) 
>+	if (rc != 0)
> 		goto neg_err_exit;
> 
> 	dialect = le16_to_cpu(pSMBr->DialectIndex);
>-	cFYI(1,("Dialect: %d", dialect));
>+	cFYI(1, ("Dialect: %d", dialect));
> 	/* Check wct = 1 error case */
>-	if((pSMBr->hdr.WordCount < 13) || (dialect == BAD_PROT)) {
>+	if ((pSMBr->hdr.WordCount < 13) || (dialect == BAD_PROT)) {
> 		/* core returns wct = 1, but we do not ask for core - otherwise
>-		small wct just comes when dialect index is -1 indicating we 
>+		small wct just comes when dialect index is -1 indicating we
> 		could not negotiate a common dialect */
> 		rc = -EOPNOTSUPP;
> 		goto neg_err_exit;
>-#ifdef CONFIG_CIFS_WEAK_PW_HASH 
>-	} else if((pSMBr->hdr.WordCount == 13)
>+#ifdef CONFIG_CIFS_WEAK_PW_HASH
>+	} else if ((pSMBr->hdr.WordCount == 13)
> 			&& ((dialect == LANMAN_PROT)
> 				|| (dialect == LANMAN2_PROT))) {
> 		__s16 tmp;
>-		struct lanman_neg_rsp * rsp = (struct lanman_neg_rsp *)pSMBr;
>+		struct lanman_neg_rsp *rsp = (struct lanman_neg_rsp *)pSMBr;
> 
>-		if((secFlags & CIFSSEC_MAY_LANMAN) || 
>+		if ((secFlags & CIFSSEC_MAY_LANMAN) ||
> 			(secFlags & CIFSSEC_MAY_PLNTXT))
> 			server->secType = LANMAN;
> 		else {
>@@ -494,7 +497,7 @@ CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
> 				   " in /proc/fs/cifs/SecurityFlags"));
> 			rc = -EOPNOTSUPP;
> 			goto neg_err_exit;
>-		}	
>+		}
> 		server->secMode = (__u8)le16_to_cpu(rsp->SecurityMode);
> 		server->maxReq = le16_to_cpu(rsp->MaxMpxCount);
> 		server->maxBuf = min((__u32)le16_to_cpu(rsp->MaxBufSize),
>@@ -502,7 +505,7 @@ CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
> 		GETU32(server->sessid) = le32_to_cpu(rsp->SessionKey);
> 		/* even though we do not use raw we might as well set this
> 		accurately, in case we ever find a need for it */
>-		if((le16_to_cpu(rsp->RawMode) & RAW_ENABLE) == RAW_ENABLE) {
>+		if ((le16_to_cpu(rsp->RawMode) & RAW_ENABLE) == RAW_ENABLE) {
> 			server->maxRw = 0xFF00;
> 			server->capabilities = CAP_MPX_MODE | CAP_RAW_MODE;
> 		} else {
>@@ -523,29 +526,29 @@ CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
> 			utc = CURRENT_TIME;
> 			ts = cnvrtDosUnixTm(le16_to_cpu(rsp->SrvTime.Date),
> 						le16_to_cpu(rsp->SrvTime.Time));
>-			cFYI(1,("SrvTime: %d sec since 1970 (utc: %d) diff: %d",
>+			cFYI(1, ("SrvTime %d sec since 1970 (utc: %d) diff: %d",
> 				(int)ts.tv_sec, (int)utc.tv_sec,
> 				(int)(utc.tv_sec - ts.tv_sec)));
> 			val = (int)(utc.tv_sec - ts.tv_sec);
>-			seconds = val < 0 ? -val : val;
>+			seconds = abs(val);
> 			result = (seconds / MIN_TZ_ADJ) * MIN_TZ_ADJ;
> 			remain = seconds % MIN_TZ_ADJ;
>-			if(remain >= (MIN_TZ_ADJ / 2))
>+			if (remain >= (MIN_TZ_ADJ / 2))
> 				result += MIN_TZ_ADJ;
>-			if(val < 0)
>+			if (val < 0)
> 				result = - result;
> 			server->timeAdj = result;
> 		} else {
> 			server->timeAdj = (int)tmp;
> 			server->timeAdj *= 60; /* also in seconds */
> 		}
>-		cFYI(1,("server->timeAdj: %d seconds", server->timeAdj));
>+		cFYI(1, ("server->timeAdj: %d seconds", server->timeAdj));
> 
> 
> 		/* BB get server time for time conversions and add
>-		code to use it and timezone since this is not UTC */	
>+		code to use it and timezone since this is not UTC */
> 
>-		if (rsp->EncryptionKeyLength == 
>+		if (rsp->EncryptionKeyLength ==
> 				cpu_to_le16(CIFS_CRYPTO_KEY_SIZE)) {
> 			memcpy(server->cryptKey, rsp->EncryptionKey,
> 				CIFS_CRYPTO_KEY_SIZE);
>@@ -554,39 +557,39 @@ CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
> 			goto neg_err_exit;
> 		}
> 
>-		cFYI(1,("LANMAN negotiated"));
>+		cFYI(1, ("LANMAN negotiated"));
> 		/* we will not end up setting signing flags - as no signing
> 		was in LANMAN and server did not return the flags on */
> 		goto signing_check;
> #else /* weak security disabled */
>-	} else if(pSMBr->hdr.WordCount == 13) {
>-		cERROR(1,("mount failed, cifs module not built "
>+	} else if (pSMBr->hdr.WordCount == 13) {
>+		cERROR(1, ("mount failed, cifs module not built "
> 			  "with CIFS_WEAK_PW_HASH support"));
> 			rc = -EOPNOTSUPP;
> #endif /* WEAK_PW_HASH */
> 		goto neg_err_exit;
>-	} else if(pSMBr->hdr.WordCount != 17) {
>+	} else if (pSMBr->hdr.WordCount != 17) {
> 		/* unknown wct */
> 		rc = -EOPNOTSUPP;
> 		goto neg_err_exit;
> 	}
> 	/* else wct == 17 NTLM */
> 	server->secMode = pSMBr->SecurityMode;
>-	if((server->secMode & SECMODE_USER) == 0)
>-		cFYI(1,("share mode security"));
>+	if ((server->secMode & SECMODE_USER) == 0)
>+		cFYI(1, ("share mode security"));
> 
>-	if((server->secMode & SECMODE_PW_ENCRYPT) == 0)
>+	if ((server->secMode & SECMODE_PW_ENCRYPT) == 0)
> #ifdef CONFIG_CIFS_WEAK_PW_HASH
> 		if ((secFlags & CIFSSEC_MAY_PLNTXT) == 0)
> #endif /* CIFS_WEAK_PW_HASH */
>-			cERROR(1,("Server requests plain text password"
>+			cERROR(1, ("Server requests plain text password"
> 				  " but client support disabled"));
> 
>-	if((secFlags & CIFSSEC_MUST_NTLMV2) == CIFSSEC_MUST_NTLMV2)
>+	if ((secFlags & CIFSSEC_MUST_NTLMV2) == CIFSSEC_MUST_NTLMV2)
> 		server->secType = NTLMv2;
>-	else if(secFlags & CIFSSEC_MAY_NTLM)
>+	else if (secFlags & CIFSSEC_MAY_NTLM)
> 		server->secType = NTLM;
>-	else if(secFlags & CIFSSEC_MAY_NTLMV2)
>+	else if (secFlags & CIFSSEC_MAY_NTLMV2)
> 		server->secType = NTLMv2;
> 	/* else krb5 ... any others ... */
> 
>@@ -615,7 +618,7 @@ CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
> 
> 	/* BB might be helpful to save off the domain of server here */
> 
>-	if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC) && 
>+	if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC) &&
> 		(server->capabilities & CAP_EXTENDED_SECURITY)) {
> 		count = pSMBr->ByteCount;
> 		if (count < 16)
>@@ -639,7 +642,7 @@ CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
> 						 SecurityBlob,
> 						 count - 16,
> 						 &server->secType);
>-			if(rc == 1) {
>+			if (rc == 1) {
> 			/* BB Need to fill struct for sessetup here */
> 				rc = -EOPNOTSUPP;
> 			} else {
>@@ -652,36 +655,37 @@ CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
> #ifdef CONFIG_CIFS_WEAK_PW_HASH
> signing_check:
> #endif
>-	if((secFlags & CIFSSEC_MAY_SIGN) == 0) {
>-		/* MUST_SIGN already includes the MAY_SIGN FLAG 
>+	if ((secFlags & CIFSSEC_MAY_SIGN) == 0) {
>+		/* MUST_SIGN already includes the MAY_SIGN FLAG
> 		   so if this is zero it means that signing is disabled */
> 		cFYI(1, ("Signing disabled"));
>-		if(server->secMode & SECMODE_SIGN_REQUIRED)
>+		if (server->secMode & SECMODE_SIGN_REQUIRED)
> 			cERROR(1, ("Server requires "
> 				   "/proc/fs/cifs/PacketSigningEnabled "
> 				   "to be on"));
>-		server->secMode &= 
>+		server->secMode &=
> 			~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
> 	} else if ((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) {
> 		/* signing required */
>-		cFYI(1, ("Must sign - segFlags 0x%x", secFlags));
>-		if((server->secMode & 
>+		cFYI(1, ("Must sign - secFlags 0x%x", secFlags));
>+		if ((server->secMode &
> 			(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED)) == 0) {
>-			cERROR(1,("signing required but server lacks support"));
>+			cERROR(1,
>+				("signing required but server lacks support"));
> 			rc = -EOPNOTSUPP;
>-		} else 
>+		} else
> 			server->secMode |= SECMODE_SIGN_REQUIRED;
> 	} else {
> 		/* signing optional ie CIFSSEC_MAY_SIGN */
>-		if((server->secMode & SECMODE_SIGN_REQUIRED) == 0)
>-			server->secMode &= 
>+		if ((server->secMode & SECMODE_SIGN_REQUIRED) == 0)
>+			server->secMode &=
> 				~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
> 	}
>-	
>-neg_err_exit:	
>+
>+neg_err_exit:
> 	cifs_buf_release(pSMB);
> 
>-	cFYI(1,("negprot rc %d",rc));
>+	cFYI(1, ("negprot rc %d", rc));
> 	return rc;
> }
> 
>@@ -698,7 +702,7 @@ CIFSSMBTDis(const int xid, struct cifsTconInfo *tcon)
> 	 *  If last user of the connection and
> 	 *  connection alive - disconnect it
> 	 *  If this is the last connection on the server session disconnect it
>-	 *  (and inside session disconnect we should check if tcp socket needs 
>+	 *  (and inside session disconnect we should check if tcp socket needs
> 	 *  to be freed and kernel thread woken up).
> 	 */
> 	if (tcon)
>@@ -712,18 +716,18 @@ CIFSSMBTDis(const int xid, struct cifsTconInfo *tcon)
> 		return -EBUSY;
> 	}
> 
>-	/* No need to return error on this operation if tid invalidated and 
>+	/* No need to return error on this operation if tid invalidated and
> 	closed on server already e.g. due to tcp session crashing */
>-	if(tcon->tidStatus == CifsNeedReconnect) {
>+	if (tcon->tidStatus == CifsNeedReconnect) {
> 		up(&tcon->tconSem);
>-		return 0;  
>+		return 0;
> 	}
> 
>-	if((tcon->ses == NULL) || (tcon->ses->server == NULL)) {    
>+	if ((tcon->ses == NULL) || (tcon->ses->server == NULL)) {
> 		up(&tcon->tconSem);
> 		return -EIO;
> 	}
>-	rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon, 
>+	rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
> 			    (void **)&smb_buffer);
> 	if (rc) {
> 		up(&tcon->tconSem);
>@@ -740,7 +744,7 @@ CIFSSMBTDis(const int xid, struct cifsTconInfo *tcon)
> 		cifs_small_buf_release(smb_buffer);
> 	up(&tcon->tconSem);
> 
>-	/* No need to return error on this operation if tid invalidated and 
>+	/* No need to return error on this operation if tid invalidated and
> 	closed on server already e.g. due to tcp session crashing */
> 	if (rc == -EAGAIN)
> 		rc = 0;
>@@ -774,11 +778,11 @@ CIFSSMBLogoff(const int xid, struct cifsSesInfo *ses)
> 	}
> 
> 	smb_buffer_response = (struct smb_hdr *)pSMB; /* BB removeme BB */
>-	
>-	if(ses->server) {
>+
>+	if (ses->server) {
> 		pSMB->hdr.Mid = GetNextMid(ses->server);
> 
>-		if(ses->server->secMode & 
>+		if (ses->server->secMode &
> 		   (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
> 			pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
> 	}
>@@ -801,7 +805,7 @@ CIFSSMBLogoff(const int xid, struct cifsSesInfo *ses)
> 	cifs_small_buf_release(pSMB);
> 
> 	/* if session dead then we do not need to do ulogoff,
>-		since server closed smb session, no sense reporting 
>+		since server closed smb session, no sense reporting
> 		error */
> 	if (rc == -EAGAIN)
> 		rc = 0;
>@@ -809,8 +813,84 @@ CIFSSMBLogoff(const int xid, struct cifsSesInfo *ses)
> }
> 
> int
>+CIFSPOSIXDelFile(const int xid, struct cifsTconInfo *tcon, const char *fileName,
>+		 __u16 type, const struct nls_table *nls_codepage, int remap)
>+{
>+	TRANSACTION2_SPI_REQ *pSMB = NULL;
>+	TRANSACTION2_SPI_RSP *pSMBr = NULL;
>+	struct unlink_psx_rq * pRqD;
>+	int name_len;
>+	int rc = 0;
>+	int bytes_returned = 0;
>+	__u16 params, param_offset, offset, byte_count;
>+
>+	cFYI(1, ("In POSIX delete"));
>+PsxDelete:
>+	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
>+		      (void **) &pSMBr);
>+	if (rc)
>+		return rc;
>+
>+	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
>+		name_len =
>+		    cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
>+				     PATH_MAX, nls_codepage, remap);
>+		name_len++;	/* trailing null */
>+		name_len *= 2;
>+	} else { /* BB add path length overrun check */ 
>+		name_len = strnlen(fileName, PATH_MAX);
>+		name_len++;	/* trailing null */
>+		strncpy(pSMB->FileName, fileName, name_len);
>+	}
>+
>+	params = 6 + name_len;
>+	pSMB->MaxParameterCount = cpu_to_le16(2);
>+	pSMB->MaxDataCount = 0; /* BB double check this with jra */
>+	pSMB->MaxSetupCount = 0;
>+	pSMB->Reserved = 0;
>+	pSMB->Flags = 0;
>+	pSMB->Timeout = 0;
>+	pSMB->Reserved2 = 0;
>+	param_offset = offsetof(struct smb_com_transaction2_spi_req,
>+				InformationLevel) - 4;
>+	offset = param_offset + params;
>+	
>+	/* Setup pointer to Request Data (inode type) */
>+	pRqD = (struct unlink_psx_rq *)(((char *)&pSMB->hdr.Protocol) + offset);
>+	pRqD->type = cpu_to_le16(type);
>+	pSMB->ParameterOffset = cpu_to_le16(param_offset);
>+	pSMB->DataOffset = cpu_to_le16(offset);
>+	pSMB->SetupCount = 1;
>+	pSMB->Reserved3 = 0;
>+	pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
>+	byte_count = 3 /* pad */  + params + sizeof(struct unlink_psx_rq);
>+
>+	pSMB->DataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
>+	pSMB->TotalDataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
>+	pSMB->ParameterCount = cpu_to_le16(params);
>+	pSMB->TotalParameterCount = pSMB->ParameterCount;
>+	pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_UNLINK);
>+	pSMB->Reserved4 = 0;
>+	pSMB->hdr.smb_buf_length += byte_count;
>+	pSMB->ByteCount = cpu_to_le16(byte_count);
>+	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
>+			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
>+	if (rc) {
>+		cFYI(1, ("Posix delete returned %d", rc));
>+	}
>+	cifs_buf_release(pSMB);
>+
>+	cifs_stats_inc(&tcon->num_deletes);
>+
>+	if (rc == -EAGAIN)
>+		goto PsxDelete;
>+
>+	return rc;
>+}
>+
>+int
> CIFSSMBDelFile(const int xid, struct cifsTconInfo *tcon, const char *fileName,
>-	       const struct nls_table *nls_codepage, int remap)
>+		const struct nls_table *nls_codepage, int remap)
> {
> 	DELETE_FILE_REQ *pSMB = NULL;
> 	DELETE_FILE_RSP *pSMBr = NULL;
>@@ -826,7 +906,7 @@ DelFileRetry:
> 
> 	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
> 		name_len =
>-		    cifsConvertToUCS((__le16 *) pSMB->fileName, fileName, 
>+		    cifsConvertToUCS((__le16 *) pSMB->fileName, fileName,
> 				     PATH_MAX, nls_codepage, remap);
> 		name_len++;	/* trailing null */
> 		name_len *= 2;
>@@ -845,7 +925,7 @@ DelFileRetry:
> 	cifs_stats_inc(&tcon->num_deletes);
> 	if (rc) {
> 		cFYI(1, ("Error in RMFile = %d", rc));
>-	} 
>+	}
> 
> 	cifs_buf_release(pSMB);
> 	if (rc == -EAGAIN)
>@@ -855,7 +935,7 @@ DelFileRetry:
> }
> 
> int
>-CIFSSMBRmDir(const int xid, struct cifsTconInfo *tcon, const char *dirName, 
>+CIFSSMBRmDir(const int xid, struct cifsTconInfo *tcon, const char *dirName,
> 	     const struct nls_table *nls_codepage, int remap)
> {
> 	DELETE_DIRECTORY_REQ *pSMB = NULL;
>@@ -916,7 +996,7 @@ MkDirRetry:
> 		return rc;
> 
> 	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
>-		name_len = cifsConvertToUCS((__le16 *) pSMB->DirName, name, 
>+		name_len = cifsConvertToUCS((__le16 *) pSMB->DirName, name,
> 					    PATH_MAX, nls_codepage, remap);
> 		name_len++;	/* trailing null */
> 		name_len *= 2;
>@@ -942,6 +1022,127 @@ MkDirRetry:
> 	return rc;
> }
> 
>+int
>+CIFSPOSIXCreate(const int xid, struct cifsTconInfo *tcon, __u32 posix_flags,
>+		__u64 mode, __u16 * netfid, FILE_UNIX_BASIC_INFO *pRetData,
>+		__u32 *pOplock, const char *name,
>+		const struct nls_table *nls_codepage, int remap)
>+{
>+	TRANSACTION2_SPI_REQ *pSMB = NULL;
>+	TRANSACTION2_SPI_RSP *pSMBr = NULL;
>+	int name_len;
>+	int rc = 0;
>+	int bytes_returned = 0;
>+	__u16 params, param_offset, offset, byte_count, count;
>+	OPEN_PSX_REQ * pdata;
>+	OPEN_PSX_RSP * psx_rsp;
>+
>+	cFYI(1, ("In POSIX Create"));
>+PsxCreat:
>+	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
>+		      (void **) &pSMBr);
>+	if (rc)
>+		return rc;
>+
>+	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
>+		name_len =
>+		    cifsConvertToUCS((__le16 *) pSMB->FileName, name,
>+				     PATH_MAX, nls_codepage, remap);
>+		name_len++;	/* trailing null */
>+		name_len *= 2;
>+	} else {	/* BB improve the check for buffer overruns BB */
>+		name_len = strnlen(name, PATH_MAX);
>+		name_len++;	/* trailing null */
>+		strncpy(pSMB->FileName, name, name_len);
>+	}
>+
>+	params = 6 + name_len;
>+	count = sizeof(OPEN_PSX_REQ);
>+	pSMB->MaxParameterCount = cpu_to_le16(2);
>+	pSMB->MaxDataCount = cpu_to_le16(1000);	/* large enough */
>+	pSMB->MaxSetupCount = 0;
>+	pSMB->Reserved = 0;
>+	pSMB->Flags = 0;
>+	pSMB->Timeout = 0;
>+	pSMB->Reserved2 = 0;
>+	param_offset = offsetof(struct smb_com_transaction2_spi_req,
>+				InformationLevel) - 4;
>+	offset = param_offset + params;
>+	pdata = (OPEN_PSX_REQ *)(((char *)&pSMB->hdr.Protocol) + offset);
>+	pdata->Level = SMB_QUERY_FILE_UNIX_BASIC;
>+	pdata->Permissions = cpu_to_le64(mode);
>+	pdata->PosixOpenFlags = cpu_to_le32(posix_flags);
>+	pdata->OpenFlags =  cpu_to_le32(*pOplock);
>+	pSMB->ParameterOffset = cpu_to_le16(param_offset);
>+	pSMB->DataOffset = cpu_to_le16(offset);
>+	pSMB->SetupCount = 1;
>+	pSMB->Reserved3 = 0;
>+	pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
>+	byte_count = 3 /* pad */  + params + count;
>+
>+	pSMB->DataCount = cpu_to_le16(count);
>+	pSMB->ParameterCount = cpu_to_le16(params);
>+	pSMB->TotalDataCount = pSMB->DataCount;
>+	pSMB->TotalParameterCount = pSMB->ParameterCount;
>+	pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_OPEN);
>+	pSMB->Reserved4 = 0;
>+	pSMB->hdr.smb_buf_length += byte_count;
>+	pSMB->ByteCount = cpu_to_le16(byte_count);
>+	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
>+			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
>+	if (rc) {
>+		cFYI(1, ("Posix create returned %d", rc));
>+		goto psx_create_err;
>+	}
>+
>+	cFYI(1, ("copying inode info"));
>+	rc = validate_t2((struct smb_t2_rsp *)pSMBr);
>+
>+	if (rc || (pSMBr->ByteCount < sizeof(OPEN_PSX_RSP))) {
>+		rc = -EIO;	/* bad smb */
>+		goto psx_create_err;
>+	}
>+
>+	/* copy return information to pRetData */
>+	psx_rsp = (OPEN_PSX_RSP *)((char *) &pSMBr->hdr.Protocol
>+			+ le16_to_cpu(pSMBr->t2.DataOffset));
>+
>+	*pOplock = le16_to_cpu(psx_rsp->OplockFlags);
>+	if (netfid)
>+		*netfid = psx_rsp->Fid;   /* cifs fid stays in le */
>+	/* Let caller know file was created so we can set the mode. */
>+	/* Do we care about the CreateAction in any other cases? */
>+	if (cpu_to_le32(FILE_CREATE) == psx_rsp->CreateAction)
>+		*pOplock |= CIFS_CREATE_ACTION;
>+	/* check to make sure response data is there */
>+	if (psx_rsp->ReturnedLevel != SMB_QUERY_FILE_UNIX_BASIC) {
>+		pRetData->Type = -1; /* unknown */
>+#ifdef CONFIG_CIFS_DEBUG2
>+		cFYI(1, ("unknown type"));
>+#endif
>+	} else {
>+		if (pSMBr->ByteCount < sizeof(OPEN_PSX_RSP)
>+					+ sizeof(FILE_UNIX_BASIC_INFO)) {
>+			cERROR(1, ("Open response data too small"));
>+			pRetData->Type = -1;
>+			goto psx_create_err;
>+		}
>+		memcpy((char *) pRetData,
>+			(char *)psx_rsp + sizeof(OPEN_PSX_RSP),
>+			sizeof(FILE_UNIX_BASIC_INFO));
>+	}
>+
>+psx_create_err:
>+	cifs_buf_release(pSMB);
>+
>+	cifs_stats_inc(&tcon->num_mkdirs);
>+
>+	if (rc == -EAGAIN)
>+		goto PsxCreat;
>+
>+	return rc;
>+}
>+
> static __u16 convert_disposition(int disposition)
> {
> 	__u16 ofun = 0;
>@@ -966,7 +1167,7 @@ static __u16 convert_disposition(int disposition)
> 			ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
> 			break;
> 		default:
>-			cFYI(1,("unknown disposition %d",disposition));
>+			cFYI(1, ("unknown disposition %d", disposition));
> 			ofun =  SMBOPEN_OAPPEND; /* regular open */
> 	}
> 	return ofun;
>@@ -976,7 +1177,7 @@ int
> SMBLegacyOpen(const int xid, struct cifsTconInfo *tcon,
> 	    const char *fileName, const int openDisposition,
> 	    const int access_flags, const int create_options, __u16 * netfid,
>-            int *pOplock, FILE_ALL_INFO * pfile_info,
>+	    int *pOplock, FILE_ALL_INFO * pfile_info,
> 	    const struct nls_table *nls_codepage, int remap)
> {
> 	int rc = -EACCES;
>@@ -1009,25 +1210,25 @@ OldOpenRetry:
> 	}
> 	if (*pOplock & REQ_OPLOCK)
> 		pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK);
>-	else if (*pOplock & REQ_BATCHOPLOCK) {
>+	else if (*pOplock & REQ_BATCHOPLOCK)
> 		pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
>-	}
>+
> 	pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
> 	/* BB fixme add conversion for access_flags to bits 0 - 2 of mode */
> 	/* 0 = read
> 	   1 = write
> 	   2 = rw
> 	   3 = execute
>-        */
>+	 */
> 	pSMB->Mode = cpu_to_le16(2);
> 	pSMB->Mode |= cpu_to_le16(0x40); /* deny none */
> 	/* set file as system file if special file such
> 	   as fifo and server expecting SFU style and
> 	   no Unix extensions */
> 
>-        if(create_options & CREATE_OPTION_SPECIAL)
>-                pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
>-        else
>+	if (create_options & CREATE_OPTION_SPECIAL)
>+		pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
>+	else
>                 pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/); /* BB FIXME */
> 
> 	/* if ((omode & S_IWUGO) == 0)
>@@ -1037,7 +1238,8 @@ OldOpenRetry:
> 	    being created */
> 
> 	/* BB FIXME BB */
>-/*	pSMB->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK); */
>+/*	pSMB->CreateOptions = cpu_to_le32(create_options &
>+						 CREATE_OPTIONS_MASK); */
> 	/* BB FIXME END BB */
> 
> 	pSMB->Sattr = cpu_to_le16(ATTR_HIDDEN | ATTR_SYSTEM | ATTR_DIRECTORY);
>@@ -1048,7 +1250,7 @@ OldOpenRetry:
> 	pSMB->ByteCount = cpu_to_le16(count);
> 	/* long_op set to 1 to allow for oplock break timeouts */
> 	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
>-		         (struct smb_hdr *) pSMBr, &bytes_returned, 1);
>+			 (struct smb_hdr *) pSMBr, &bytes_returned, 1);
> 	cifs_stats_inc(&tcon->num_opens);
> 	if (rc) {
> 		cFYI(1, ("Error in Open = %d", rc));
>@@ -1061,17 +1263,17 @@ OldOpenRetry:
> 		/* Let caller know file was created so we can set the mode. */
> 		/* Do we care about the CreateAction in any other cases? */
> 	/* BB FIXME BB */
>-/*		if(cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
>+/*		if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
> 			*pOplock |= CIFS_CREATE_ACTION; */
> 	/* BB FIXME END */
> 
>-		if(pfile_info) {
>+		if (pfile_info) {
> 			pfile_info->CreationTime = 0; /* BB convert CreateTime*/
> 			pfile_info->LastAccessTime = 0; /* BB fixme */
> 			pfile_info->LastWriteTime = 0; /* BB fixme */
> 			pfile_info->ChangeTime = 0;  /* BB fixme */
> 			pfile_info->Attributes =
>-				cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes)); 
>+				cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes));
> 			/* the file_info buf is endian converted by caller */
> 			pfile_info->AllocationSize =
> 				cpu_to_le64(le32_to_cpu(pSMBr->EndOfFile));
>@@ -1090,7 +1292,7 @@ int
> CIFSSMBOpen(const int xid, struct cifsTconInfo *tcon,
> 	    const char *fileName, const int openDisposition,
> 	    const int access_flags, const int create_options, __u16 * netfid,
>-	    int *pOplock, FILE_ALL_INFO * pfile_info, 
>+	    int *pOplock, FILE_ALL_INFO * pfile_info,
> 	    const struct nls_table *nls_codepage, int remap)
> {
> 	int rc = -EACCES;
>@@ -1125,15 +1327,14 @@ openRetry:
> 	}
> 	if (*pOplock & REQ_OPLOCK)
> 		pSMB->OpenFlags = cpu_to_le32(REQ_OPLOCK);
>-	else if (*pOplock & REQ_BATCHOPLOCK) {
>+	else if (*pOplock & REQ_BATCHOPLOCK)
> 		pSMB->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
>-	}
> 	pSMB->DesiredAccess = cpu_to_le32(access_flags);
> 	pSMB->AllocationSize = 0;
> 	/* set file as system file if special file such
> 	   as fifo and server expecting SFU style and
> 	   no Unix extensions */
>-	if(create_options & CREATE_OPTION_SPECIAL)
>+	if (create_options & CREATE_OPTION_SPECIAL)
> 		pSMB->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
> 	else
> 		pSMB->FileAttributes = cpu_to_le32(ATTR_NORMAL);
>@@ -1171,10 +1372,10 @@ openRetry:
> 		*netfid = pSMBr->Fid;	/* cifs fid stays in le */
> 		/* Let caller know file was created so we can set the mode. */
> 		/* Do we care about the CreateAction in any other cases? */
>-		if(cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
>-			*pOplock |= CIFS_CREATE_ACTION; 
>-		if(pfile_info) {
>-		    memcpy((char *)pfile_info,(char *)&pSMBr->CreationTime,
>+		if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
>+			*pOplock |= CIFS_CREATE_ACTION;
>+		if (pfile_info) {
>+		    memcpy((char *)pfile_info, (char *)&pSMBr->CreationTime,
> 			36 /* CreationTime to Attributes */);
> 		    /* the file_info buf is endian converted by caller */
> 		    pfile_info->AllocationSize = pSMBr->AllocationSize;
>@@ -1190,10 +1391,9 @@ openRetry:
> }
> 
> int
>-CIFSSMBRead(const int xid, struct cifsTconInfo *tcon,
>-            const int netfid, const unsigned int count,
>-            const __u64 lseek, unsigned int *nbytes, char **buf,
>-	    int * pbuf_type)
>+CIFSSMBRead(const int xid, struct cifsTconInfo *tcon, const int netfid,
>+	    const unsigned int count, const __u64 lseek, unsigned int *nbytes,
>+	    char **buf, int *pbuf_type)
> {
> 	int rc = -EACCES;
> 	READ_REQ *pSMB = NULL;
>@@ -1203,8 +1403,8 @@ CIFSSMBRead(const int xid, struct cifsTconInfo *tcon,
> 	int resp_buf_type = 0;
> 	struct kvec iov[1];
> 
>-	cFYI(1,("Reading %d bytes on fid %d",count,netfid));
>-	if(tcon->ses->capabilities & CAP_LARGE_FILES)
>+	cFYI(1, ("Reading %d bytes on fid %d", count, netfid));
>+	if (tcon->ses->capabilities & CAP_LARGE_FILES)
> 		wct = 12;
> 	else
> 		wct = 10; /* old style read */
>@@ -1221,28 +1421,28 @@ CIFSSMBRead(const int xid, struct cifsTconInfo *tcon,
> 	pSMB->AndXCommand = 0xFF;       /* none */
> 	pSMB->Fid = netfid;
> 	pSMB->OffsetLow = cpu_to_le32(lseek & 0xFFFFFFFF);
>-	if(wct == 12)
>+	if (wct == 12)
> 		pSMB->OffsetHigh = cpu_to_le32(lseek >> 32);
>-	else if((lseek >> 32) > 0) /* can not handle this big offset for old */
>+	else if ((lseek >> 32) > 0) /* can not handle this big offset for old */
> 		return -EIO;
> 
> 	pSMB->Remaining = 0;
> 	pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
> 	pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
>-	if(wct == 12)
>+	if (wct == 12)
> 		pSMB->ByteCount = 0;  /* no need to do le conversion since 0 */
> 	else {
> 		/* old style read */
>-		struct smb_com_readx_req * pSMBW =
>+		struct smb_com_readx_req *pSMBW =
> 			(struct smb_com_readx_req *)pSMB;
> 		pSMBW->ByteCount = 0;
> 	}
> 
> 	iov[0].iov_base = (char *)pSMB;
> 	iov[0].iov_len = pSMB->hdr.smb_buf_length + 4;
>-	rc = SendReceive2(xid, tcon->ses, iov, 
>+	rc = SendReceive2(xid, tcon->ses, iov,
> 			  1 /* num iovecs */,
>-			  &resp_buf_type, 0); 
>+			  &resp_buf_type, 0);
> 	cifs_stats_inc(&tcon->num_reads);
> 	pSMBr = (READ_RSP *)iov[0].iov_base;
> 	if (rc) {
>@@ -1256,33 +1456,34 @@ CIFSSMBRead(const int xid, struct cifsTconInfo *tcon,
> 		/*check that DataLength would not go beyond end of SMB */
> 		if ((data_length > CIFSMaxBufSize)
> 				|| (data_length > count)) {
>-			cFYI(1,("bad length %d for count %d",data_length,count));
>+			cFYI(1, ("bad length %d for count %d",
>+				 data_length, count));
> 			rc = -EIO;
> 			*nbytes = 0;
> 		} else {
> 			pReadData = (char *) (&pSMBr->hdr.Protocol) +
>-			    le16_to_cpu(pSMBr->DataOffset);
>-/*                      if(rc = copy_to_user(buf, pReadData, data_length)) {
>-                                cERROR(1,("Faulting on read rc = %d",rc));
>-                                rc = -EFAULT;
>-                        }*/ /* can not use copy_to_user when using page cache*/
>-			if(*buf)
>-				memcpy(*buf,pReadData,data_length);
>+					le16_to_cpu(pSMBr->DataOffset);
>+/*			if (rc = copy_to_user(buf, pReadData, data_length)) {
>+				cERROR(1,("Faulting on read rc = %d",rc));
>+				rc = -EFAULT;
>+			}*/ /* can not use copy_to_user when using page cache*/
>+			if (*buf)
>+				memcpy(*buf, pReadData, data_length);
> 		}
> 	}
> 
> /*	cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
>-	if(*buf) {
>-		if(resp_buf_type == CIFS_SMALL_BUFFER)
>+	if (*buf) {
>+		if (resp_buf_type == CIFS_SMALL_BUFFER)
> 			cifs_small_buf_release(iov[0].iov_base);
>-		else if(resp_buf_type == CIFS_LARGE_BUFFER)
>+		else if (resp_buf_type == CIFS_LARGE_BUFFER)
> 			cifs_buf_release(iov[0].iov_base);
>-	} else if(resp_buf_type != CIFS_NO_BUFFER) {
>-		/* return buffer to caller to free */ 
>-		*buf = iov[0].iov_base;		
>-		if(resp_buf_type == CIFS_SMALL_BUFFER)
>+	} else if (resp_buf_type != CIFS_NO_BUFFER) {
>+		/* return buffer to caller to free */
>+		*buf = iov[0].iov_base;
>+		if (resp_buf_type == CIFS_SMALL_BUFFER)
> 			*pbuf_type = CIFS_SMALL_BUFFER;
>-		else if(resp_buf_type == CIFS_LARGE_BUFFER)
>+		else if (resp_buf_type == CIFS_LARGE_BUFFER)
> 			*pbuf_type = CIFS_LARGE_BUFFER;
> 	} /* else no valid buffer on return - leave as null */
> 
>@@ -1296,7 +1497,7 @@ int
> CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
> 	     const int netfid, const unsigned int count,
> 	     const __u64 offset, unsigned int *nbytes, const char *buf,
>-	     const char __user * ubuf, const int long_op)
>+	     const char __user *ubuf, const int long_op)
> {
> 	int rc = -EACCES;
> 	WRITE_REQ *pSMB = NULL;
>@@ -1306,10 +1507,10 @@ CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
> 	__u16 byte_count;
> 
> 	/* cFYI(1,("write at %lld %d bytes",offset,count));*/
>-	if(tcon->ses == NULL)
>+	if (tcon->ses == NULL)
> 		return -ECONNABORTED;
> 
>-	if(tcon->ses->capabilities & CAP_LARGE_FILES)
>+	if (tcon->ses->capabilities & CAP_LARGE_FILES)
> 		wct = 14;
> 	else
> 		wct = 12;
>@@ -1325,20 +1526,20 @@ CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
> 	pSMB->AndXCommand = 0xFF;	/* none */
> 	pSMB->Fid = netfid;
> 	pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
>-	if(wct == 14) 
>+	if (wct == 14)
> 		pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
>-	else if((offset >> 32) > 0) /* can not handle this big offset for old */
>+	else if ((offset >> 32) > 0) /* can not handle big offset for old srv */
> 		return -EIO;
>-	
>+
> 	pSMB->Reserved = 0xFFFFFFFF;
> 	pSMB->WriteMode = 0;
> 	pSMB->Remaining = 0;
> 
>-	/* Can increase buffer size if buffer is big enough in some cases - ie we 
>+	/* Can increase buffer size if buffer is big enough in some cases ie we
> 	can send more if LARGE_WRITE_X capability returned by the server and if
> 	our buffer is big enough or if we convert to iovecs on socket writes
> 	and eliminate the copy to the CIFS buffer */
>-	if(tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
>+	if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
> 		bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
> 	} else {
> 		bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
>@@ -1348,11 +1549,11 @@ CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
> 	if (bytes_sent > count)
> 		bytes_sent = count;
> 	pSMB->DataOffset =
>-		cpu_to_le16(offsetof(struct smb_com_write_req,Data) - 4);
>-	if(buf)
>-	    memcpy(pSMB->Data,buf,bytes_sent);
>-	else if(ubuf) {
>-		if(copy_from_user(pSMB->Data,ubuf,bytes_sent)) {
>+		cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
>+	if (buf)
>+	    memcpy(pSMB->Data, buf, bytes_sent);
>+	else if (ubuf) {
>+		if (copy_from_user(pSMB->Data, ubuf, bytes_sent)) {
> 			cifs_buf_release(pSMB);
> 			return -EFAULT;
> 		}
>@@ -1361,7 +1562,7 @@ CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
> 		cifs_buf_release(pSMB);
> 		return -EINVAL;
> 	} /* else setting file size with write of zero bytes */
>-	if(wct == 14)
>+	if (wct == 14)
> 		byte_count = bytes_sent + 1; /* pad */
> 	else /* wct == 12 */ {
> 		byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
>@@ -1370,10 +1571,11 @@ CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
> 	pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
> 	pSMB->hdr.smb_buf_length += byte_count;
> 
>-	if(wct == 14)
>+	if (wct == 14)
> 		pSMB->ByteCount = cpu_to_le16(byte_count);
>-	else { /* old style write has byte count 4 bytes earlier so 4 bytes pad  */
>-		struct smb_com_writex_req * pSMBW = 
>+	else { /* old style write has byte count 4 bytes earlier
>+		  so 4 bytes pad  */
>+		struct smb_com_writex_req *pSMBW =
> 			(struct smb_com_writex_req *)pSMB;
> 		pSMBW->ByteCount = cpu_to_le16(byte_count);
> 	}
>@@ -1392,7 +1594,7 @@ CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
> 
> 	cifs_buf_release(pSMB);
> 
>-	/* Note: On -EAGAIN error only caller can retry on handle based calls 
>+	/* Note: On -EAGAIN error only caller can retry on handle based calls
> 		since file handle passed in no longer valid */
> 
> 	return rc;
>@@ -1410,9 +1612,9 @@ CIFSSMBWrite2(const int xid, struct cifsTconInfo *tcon,
> 	int smb_hdr_len;
> 	int resp_buf_type = 0;
> 
>-	cFYI(1,("write2 at %lld %d bytes", (long long)offset, count));
>+	cFYI(1, ("write2 at %lld %d bytes", (long long)offset, count));
> 
>-	if(tcon->ses->capabilities & CAP_LARGE_FILES)
>+	if (tcon->ses->capabilities & CAP_LARGE_FILES)
> 		wct = 14;
> 	else
> 		wct = 12;
>@@ -1426,37 +1628,37 @@ CIFSSMBWrite2(const int xid, struct cifsTconInfo *tcon,
> 	pSMB->AndXCommand = 0xFF;	/* none */
> 	pSMB->Fid = netfid;
> 	pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
>-	if(wct == 14)
>+	if (wct == 14)
> 		pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
>-	else if((offset >> 32) > 0) /* can not handle this big offset for old */
>+	else if ((offset >> 32) > 0) /* can not handle big offset for old srv */
> 		return -EIO;
> 	pSMB->Reserved = 0xFFFFFFFF;
> 	pSMB->WriteMode = 0;
> 	pSMB->Remaining = 0;
> 
> 	pSMB->DataOffset =
>-	    cpu_to_le16(offsetof(struct smb_com_write_req,Data) - 4);
>+	    cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
> 
> 	pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF);
> 	pSMB->DataLengthHigh = cpu_to_le16(count >> 16);
> 	smb_hdr_len = pSMB->hdr.smb_buf_length + 1; /* hdr + 1 byte pad */
>-	if(wct == 14)
>+	if (wct == 14)
> 		pSMB->hdr.smb_buf_length += count+1;
> 	else /* wct == 12 */
>-		pSMB->hdr.smb_buf_length += count+5; /* smb data starts later */ 
>-	if(wct == 14)
>+		pSMB->hdr.smb_buf_length += count+5; /* smb data starts later */
>+	if (wct == 14)
> 		pSMB->ByteCount = cpu_to_le16(count + 1);
> 	else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
>-		struct smb_com_writex_req * pSMBW =
>+		struct smb_com_writex_req *pSMBW =
> 				(struct smb_com_writex_req *)pSMB;
> 		pSMBW->ByteCount = cpu_to_le16(count + 5);
> 	}
> 	iov[0].iov_base = pSMB;
>-	if(wct == 14)
>+	if (wct == 14)
> 		iov[0].iov_len = smb_hdr_len + 4;
> 	else /* wct == 12 pad bigger by four bytes */
> 		iov[0].iov_len = smb_hdr_len + 8;
>-	
>+
> 
> 	rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type,
> 			  long_op);
>@@ -1464,7 +1666,7 @@ CIFSSMBWrite2(const int xid, struct cifsTconInfo *tcon,
> 	if (rc) {
> 		cFYI(1, ("Send error Write2 = %d", rc));
> 		*nbytes = 0;
>-	} else if(resp_buf_type == 0) {
>+	} else if (resp_buf_type == 0) {
> 		/* presumably this can not happen, but best to be safe */
> 		rc = -EIO;
> 		*nbytes = 0;
>@@ -1473,15 +1675,15 @@ CIFSSMBWrite2(const int xid, struct cifsTconInfo *tcon,
> 		*nbytes = le16_to_cpu(pSMBr->CountHigh);
> 		*nbytes = (*nbytes) << 16;
> 		*nbytes += le16_to_cpu(pSMBr->Count);
>-	} 
>+	}
> 
> /*	cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
>-	if(resp_buf_type == CIFS_SMALL_BUFFER)
>+	if (resp_buf_type == CIFS_SMALL_BUFFER)
> 		cifs_small_buf_release(iov[0].iov_base);
>-	else if(resp_buf_type == CIFS_LARGE_BUFFER)
>+	else if (resp_buf_type == CIFS_LARGE_BUFFER)
> 		cifs_buf_release(iov[0].iov_base);
> 
>-	/* Note: On -EAGAIN error only caller can retry on handle based calls 
>+	/* Note: On -EAGAIN error only caller can retry on handle based calls
> 		since file handle passed in no longer valid */
> 
> 	return rc;
>@@ -1501,7 +1703,7 @@ CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
> 	int timeout = 0;
> 	__u16 count;
> 
>-	cFYI(1, ("In CIFSSMBLock - timeout %d numLock %d",waitFlag,numLock));
>+	cFYI(1, ("In CIFSSMBLock - timeout %d numLock %d", waitFlag, numLock));
> 	rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
> 
> 	if (rc)
>@@ -1509,7 +1711,7 @@ CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
> 
> 	pSMBr = (LOCK_RSP *)pSMB; /* BB removeme BB */
> 
>-	if(lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
>+	if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
> 		timeout = -1; /* no response expected */
> 		pSMB->Timeout = 0;
> 	} else if (waitFlag == TRUE) {
>@@ -1525,7 +1727,7 @@ CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
> 	pSMB->AndXCommand = 0xFF;	/* none */
> 	pSMB->Fid = smb_file_id; /* netfid stays le */
> 
>-	if((numLock != 0) || (numUnlock != 0)) {
>+	if ((numLock != 0) || (numUnlock != 0)) {
> 		pSMB->Locks[0].Pid = cpu_to_le16(current->tgid);
> 		/* BB where to store pid high? */
> 		pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
>@@ -1553,7 +1755,7 @@ CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
> 	}
> 	cifs_small_buf_release(pSMB);
> 
>-	/* Note: On -EAGAIN error only caller can retry on handle based calls 
>+	/* Note: On -EAGAIN error only caller can retry on handle based calls
> 	since file handle passed in no longer valid */
> 	return rc;
> }
>@@ -1561,12 +1763,11 @@ CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
> int
> CIFSSMBPosixLock(const int xid, struct cifsTconInfo *tcon,
> 		const __u16 smb_file_id, const int get_flag, const __u64 len,
>-		struct file_lock *pLockData, const __u16 lock_type, 
>+		struct file_lock *pLockData, const __u16 lock_type,
> 		const int waitFlag)
> {
> 	struct smb_com_transaction2_sfi_req *pSMB  = NULL;
> 	struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
>-	char *data_offset;
> 	struct cifs_posix_lock *parm_data;
> 	int rc = 0;
> 	int timeout = 0;
>@@ -1575,7 +1776,7 @@ CIFSSMBPosixLock(const int xid, struct cifsTconInfo *tcon,
> 
> 	cFYI(1, ("Posix Lock"));
> 
>-	if(pLockData == NULL)
>+	if (pLockData == NULL)
> 		return EINVAL;
> 
> 	rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
>@@ -1585,7 +1786,7 @@ CIFSSMBPosixLock(const int xid, struct cifsTconInfo *tcon,
> 
> 	pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
> 
>-	params = 6; 
>+	params = 6;
> 	pSMB->MaxSetupCount = 0;
> 	pSMB->Reserved = 0;
> 	pSMB->Flags = 0;
>@@ -1593,14 +1794,12 @@ CIFSSMBPosixLock(const int xid, struct cifsTconInfo *tcon,
> 	param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
> 	offset = param_offset + params;
> 
>-	data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
>-
> 	count = sizeof(struct cifs_posix_lock);
> 	pSMB->MaxParameterCount = cpu_to_le16(2);
> 	pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
> 	pSMB->SetupCount = 1;
> 	pSMB->Reserved3 = 0;
>-	if(get_flag)
>+	if (get_flag)
> 		pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
> 	else
> 		pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
>@@ -1610,11 +1809,11 @@ CIFSSMBPosixLock(const int xid, struct cifsTconInfo *tcon,
> 	pSMB->TotalDataCount = pSMB->DataCount;
> 	pSMB->TotalParameterCount = pSMB->ParameterCount;
> 	pSMB->ParameterOffset = cpu_to_le16(param_offset);
>-	parm_data = (struct cifs_posix_lock *) 
>+	parm_data = (struct cifs_posix_lock *)
> 			(((char *) &pSMB->hdr.Protocol) + offset);
> 
> 	parm_data->lock_type = cpu_to_le16(lock_type);
>-	if(waitFlag) {
>+	if (waitFlag) {
> 		timeout = 3;  /* blocking operation, no timeout */
> 		parm_data->lock_flags = cpu_to_le16(1);
> 		pSMB->Timeout = cpu_to_le32(-1);
>@@ -1651,22 +1850,22 @@ CIFSSMBPosixLock(const int xid, struct cifsTconInfo *tcon,
> 			rc = -EIO;      /* bad smb */
> 			goto plk_err_exit;
> 		}
>-		if(pLockData == NULL) {
>+		if (pLockData == NULL) {
> 			rc = -EINVAL;
> 			goto plk_err_exit;
> 		}
> 		data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
> 		data_count  = le16_to_cpu(pSMBr->t2.DataCount);
>-		if(data_count < sizeof(struct cifs_posix_lock)) {
>+		if (data_count < sizeof(struct cifs_posix_lock)) {
> 			rc = -EIO;
> 			goto plk_err_exit;
> 		}
> 		parm_data = (struct cifs_posix_lock *)
> 			((char *)&pSMBr->hdr.Protocol + data_offset);
>-		if(parm_data->lock_type == cpu_to_le16(CIFS_UNLCK))
>+		if (parm_data->lock_type == cpu_to_le16(CIFS_UNLCK))
> 			pLockData->fl_type = F_UNLCK;
> 	}
>- 
>+
> plk_err_exit:
> 	if (pSMB)
> 		cifs_small_buf_release(pSMB);
>@@ -1689,7 +1888,7 @@ CIFSSMBClose(const int xid, struct cifsTconInfo *tcon, int smb_file_id)
> 
> /* do not retry on dead session on close */
> 	rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
>-	if(rc == -EAGAIN)
>+	if (rc == -EAGAIN)
> 		return 0;
> 	if (rc)
> 		return rc;
>@@ -1703,7 +1902,7 @@ CIFSSMBClose(const int xid, struct cifsTconInfo *tcon, int smb_file_id)
> 			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
> 	cifs_stats_inc(&tcon->num_closes);
> 	if (rc) {
>-		if(rc!=-EINTR) {
>+		if (rc != -EINTR) {
> 			/* EINTR is expected when user ctl-c to kill app */
> 			cERROR(1, ("Send error in Close = %d", rc));
> 		}
>@@ -1712,7 +1911,7 @@ CIFSSMBClose(const int xid, struct cifsTconInfo *tcon, int smb_file_id)
> 	cifs_small_buf_release(pSMB);
> 
> 	/* Since session is dead, file will be closed on server already */
>-	if(rc == -EAGAIN)
>+	if (rc == -EAGAIN)
> 		rc = 0;
> 
> 	return rc;
>@@ -1744,7 +1943,7 @@ renameRetry:
> 
> 	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
> 		name_len =
>-		    cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName, 
>+		    cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
> 				     PATH_MAX, nls_codepage, remap);
> 		name_len++;	/* trailing null */
> 		name_len *= 2;
>@@ -1756,7 +1955,7 @@ renameRetry:
> 				     toName, PATH_MAX, nls_codepage, remap);
> 		name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
> 		name_len2 *= 2;	/* convert to bytes */
>-	} else {		/* BB improve the check for buffer overruns BB */
>+	} else {	/* BB improve the check for buffer overruns BB */
> 		name_len = strnlen(fromName, PATH_MAX);
> 		name_len++;	/* trailing null */
> 		strncpy(pSMB->OldFileName, fromName, name_len);
>@@ -1777,7 +1976,7 @@ renameRetry:
> 	cifs_stats_inc(&tcon->num_renames);
> 	if (rc) {
> 		cFYI(1, ("Send error in rename = %d", rc));
>-	} 
>+	}
> 
> 	cifs_buf_release(pSMB);
> 
>@@ -1787,13 +1986,13 @@ renameRetry:
> 	return rc;
> }
> 
>-int CIFSSMBRenameOpenFile(const int xid,struct cifsTconInfo *pTcon, 
>-		int netfid, char * target_name, 
>-		const struct nls_table * nls_codepage, int remap)
>+int CIFSSMBRenameOpenFile(const int xid, struct cifsTconInfo *pTcon,
>+		int netfid, char *target_name,
>+		const struct nls_table *nls_codepage, int remap)
> {
> 	struct smb_com_transaction2_sfi_req *pSMB  = NULL;
> 	struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
>-	struct set_file_rename * rename_info;
>+	struct set_file_rename *rename_info;
> 	char *data_offset;
> 	char dummy_string[30];
> 	int rc = 0;
>@@ -1832,13 +2031,14 @@ int CIFSSMBRenameOpenFile(const int xid,struct cifsTconInfo *pTcon,
> 	rename_info->overwrite = cpu_to_le32(1);
> 	rename_info->root_fid  = 0;
> 	/* unicode only call */
>-	if(target_name == NULL) {
>-		sprintf(dummy_string,"cifs%x",pSMB->hdr.Mid);
>-	        len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
>+	if (target_name == NULL) {
>+		sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid);
>+		len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
> 					dummy_string, 24, nls_codepage, remap);
> 	} else {
> 		len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
>-					target_name, PATH_MAX, nls_codepage, remap);
>+					target_name, PATH_MAX, nls_codepage,
>+					remap);
> 	}
> 	rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
> 	count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str) + 2;
>@@ -1852,10 +2052,10 @@ int CIFSSMBRenameOpenFile(const int xid,struct cifsTconInfo *pTcon,
> 	pSMB->hdr.smb_buf_length += byte_count;
> 	pSMB->ByteCount = cpu_to_le16(byte_count);
> 	rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
>-                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
>+			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
> 	cifs_stats_inc(&pTcon->num_t2renames);
> 	if (rc) {
>-		cFYI(1,("Send error in Rename (by file handle) = %d", rc));
>+		cFYI(1, ("Send error in Rename (by file handle) = %d", rc));
> 	}
> 
> 	cifs_buf_release(pSMB);
>@@ -1867,9 +2067,9 @@ int CIFSSMBRenameOpenFile(const int xid,struct cifsTconInfo *pTcon,
> }
> 
> int
>-CIFSSMBCopy(const int xid, struct cifsTconInfo *tcon, const char * fromName, 
>-            const __u16 target_tid, const char *toName, const int flags,
>-            const struct nls_table *nls_codepage, int remap)
>+CIFSSMBCopy(const int xid, struct cifsTconInfo *tcon, const char *fromName,
>+	    const __u16 target_tid, const char *toName, const int flags,
>+	    const struct nls_table *nls_codepage, int remap)
> {
> 	int rc = 0;
> 	COPY_REQ *pSMB = NULL;
>@@ -1891,7 +2091,7 @@ copyRetry:
> 	pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
> 
> 	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
>-		name_len = cifsConvertToUCS((__le16 *) pSMB->OldFileName, 
>+		name_len = cifsConvertToUCS((__le16 *) pSMB->OldFileName,
> 					    fromName, PATH_MAX, nls_codepage,
> 					    remap);
> 		name_len++;     /* trailing null */
>@@ -1899,11 +2099,12 @@ copyRetry:
> 		pSMB->OldFileName[name_len] = 0x04;     /* pad */
> 		/* protocol requires ASCII signature byte on Unicode string */
> 		pSMB->OldFileName[name_len + 1] = 0x00;
>-		name_len2 = cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2], 
>+		name_len2 =
>+		    cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
> 				toName, PATH_MAX, nls_codepage, remap);
> 		name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
> 		name_len2 *= 2; /* convert to bytes */
>-	} else {                /* BB improve the check for buffer overruns BB */
>+	} else { 	/* BB improve the check for buffer overruns BB */
> 		name_len = strnlen(fromName, PATH_MAX);
> 		name_len++;     /* trailing null */
> 		strncpy(pSMB->OldFileName, fromName, name_len);
>@@ -1963,7 +2164,7 @@ createSymLinkRetry:
> 		name_len++;	/* trailing null */
> 		name_len *= 2;
> 
>-	} else {		/* BB improve the check for buffer overruns BB */
>+	} else {	/* BB improve the check for buffer overruns BB */
> 		name_len = strnlen(fromName, PATH_MAX);
> 		name_len++;	/* trailing null */
> 		strncpy(pSMB->FileName, fromName, name_len);
>@@ -1975,7 +2176,7 @@ createSymLinkRetry:
> 	pSMB->Timeout = 0;
> 	pSMB->Reserved2 = 0;
> 	param_offset = offsetof(struct smb_com_transaction2_spi_req,
>-                                     InformationLevel) - 4;
>+				InformationLevel) - 4;
> 	offset = param_offset + params;
> 
> 	data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
>@@ -1986,7 +2187,7 @@ createSymLinkRetry:
> 				  , nls_codepage);
> 		name_len_target++;	/* trailing null */
> 		name_len_target *= 2;
>-	} else {		/* BB improve the check for buffer overruns BB */
>+	} else {	/* BB improve the check for buffer overruns BB */
> 		name_len_target = strnlen(toName, PATH_MAX);
> 		name_len_target++;	/* trailing null */
> 		strncpy(data_offset, toName, name_len_target);
>@@ -2013,9 +2214,7 @@ createSymLinkRetry:
> 			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
> 	cifs_stats_inc(&tcon->num_symlinks);
> 	if (rc) {
>-		cFYI(1,
>-		     ("Send error in SetPathInfo (create symlink) = %d",
>-		      rc));
>+		cFYI(1, ("Send error in SetPathInfo create symlink = %d", rc));
> 	}
> 
> 	if (pSMB)
>@@ -2054,7 +2253,7 @@ createHardLinkRetry:
> 		name_len++;	/* trailing null */
> 		name_len *= 2;
> 
>-	} else {		/* BB improve the check for buffer overruns BB */
>+	} else {	/* BB improve the check for buffer overruns BB */
> 		name_len = strnlen(toName, PATH_MAX);
> 		name_len++;	/* trailing null */
> 		strncpy(pSMB->FileName, toName, name_len);
>@@ -2066,7 +2265,7 @@ createHardLinkRetry:
> 	pSMB->Timeout = 0;
> 	pSMB->Reserved2 = 0;
> 	param_offset = offsetof(struct smb_com_transaction2_spi_req,
>-                                     InformationLevel) - 4;
>+				InformationLevel) - 4;
> 	offset = param_offset + params;
> 
> 	data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
>@@ -2076,7 +2275,7 @@ createHardLinkRetry:
> 				     nls_codepage, remap);
> 		name_len_target++;	/* trailing null */
> 		name_len_target *= 2;
>-	} else {		/* BB improve the check for buffer overruns BB */
>+	} else {	/* BB improve the check for buffer overruns BB */
> 		name_len_target = strnlen(fromName, PATH_MAX);
> 		name_len_target++;	/* trailing null */
> 		strncpy(data_offset, fromName, name_len_target);
>@@ -2148,13 +2347,13 @@ winCreateHardLinkRetry:
> 		name_len++;	/* trailing null */
> 		name_len *= 2;
> 		pSMB->OldFileName[name_len] = 0;	/* pad */
>-		pSMB->OldFileName[name_len + 1] = 0x04; 
>+		pSMB->OldFileName[name_len + 1] = 0x04;
> 		name_len2 =
>-		    cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2], 
>+		    cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
> 				     toName, PATH_MAX, nls_codepage, remap);
> 		name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
> 		name_len2 *= 2;	/* convert to bytes */
>-	} else {		/* BB improve the check for buffer overruns BB */
>+	} else {	/* BB improve the check for buffer overruns BB */
> 		name_len = strnlen(fromName, PATH_MAX);
> 		name_len++;	/* trailing null */
> 		strncpy(pSMB->OldFileName, fromName, name_len);
>@@ -2207,12 +2406,11 @@ querySymLinkRetry:
> 
> 	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
> 		name_len =
>-		    cifs_strtoUCS((__le16 *) pSMB->FileName, searchName, PATH_MAX
>-				  /* find define for this maxpathcomponent */
>-				  , nls_codepage);
>+		    cifs_strtoUCS((__le16 *) pSMB->FileName, searchName,
>+				  PATH_MAX, nls_codepage);
> 		name_len++;	/* trailing null */
> 		name_len *= 2;
>-	} else {		/* BB improve the check for buffer overruns BB */
>+	} else {	/* BB improve the check for buffer overruns BB */
> 		name_len = strnlen(searchName, PATH_MAX);
> 		name_len++;	/* trailing null */
> 		strncpy(pSMB->FileName, searchName, name_len);
>@@ -2229,7 +2427,7 @@ querySymLinkRetry:
> 	pSMB->Timeout = 0;
> 	pSMB->Reserved2 = 0;
> 	pSMB->ParameterOffset = cpu_to_le16(offsetof(
>-        struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
>+	struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
> 	pSMB->DataCount = 0;
> 	pSMB->DataOffset = 0;
> 	pSMB->SetupCount = 1;
>@@ -2260,16 +2458,16 @@ querySymLinkRetry:
> 
> 			if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
> 				name_len = UniStrnlen((wchar_t *) ((char *)
>-					&pSMBr->hdr.Protocol +data_offset),
>-					min_t(const int, buflen,count) / 2);
>+					&pSMBr->hdr.Protocol + data_offset),
>+					min_t(const int, buflen, count) / 2);
> 			/* BB FIXME investigate remapping reserved chars here */
> 				cifs_strfromUCS_le(symlinkinfo,
>-					(__le16 *) ((char *)&pSMBr->hdr.Protocol +
>-						data_offset),
>+					(__le16 *) ((char *)&pSMBr->hdr.Protocol
>+							+ data_offset),
> 					name_len, nls_codepage);
> 			} else {
> 				strncpy(symlinkinfo,
>-					(char *) &pSMBr->hdr.Protocol + 
>+					(char *) &pSMBr->hdr.Protocol +
> 						data_offset,
> 					min_t(const int, buflen, count));
> 			}
>@@ -2290,14 +2488,14 @@ querySymLinkRetry:
> 	Setup words themselves and ByteCount
> 	MaxSetupCount (size of returned setup area) and
> 	MaxParameterCount (returned parms size) must be set by caller */
>-static int 
>+static int
> smb_init_ntransact(const __u16 sub_command, const int setup_count,
> 		   const int parm_len, struct cifsTconInfo *tcon,
>-		   void ** ret_buf)
>+		   void **ret_buf)
> {
> 	int rc;
> 	__u32 temp_offset;
>-	struct smb_com_ntransact_req * pSMB;
>+	struct smb_com_ntransact_req *pSMB;
> 
> 	rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
> 				(void **)&pSMB);
>@@ -2321,47 +2519,47 @@ smb_init_ntransact(const __u16 sub_command, const int setup_count,
> }
> 
> static int
>-validate_ntransact(char * buf, char ** ppparm, char ** ppdata,
>-		   int * pdatalen, int * pparmlen)
>+validate_ntransact(char *buf, char **ppparm, char **ppdata,
>+		   int *pdatalen, int *pparmlen)
> {
>-	char * end_of_smb;
>+	char *end_of_smb;
> 	__u32 data_count, data_offset, parm_count, parm_offset;
>-	struct smb_com_ntransact_rsp * pSMBr;
>+	struct smb_com_ntransact_rsp *pSMBr;
> 
>-	if(buf == NULL)
>+	if (buf == NULL)
> 		return -EINVAL;
> 
> 	pSMBr = (struct smb_com_ntransact_rsp *)buf;
> 
> 	/* ByteCount was converted from little endian in SendReceive */
>-	end_of_smb = 2 /* sizeof byte count */ + pSMBr->ByteCount + 
>+	end_of_smb = 2 /* sizeof byte count */ + pSMBr->ByteCount +
> 			(char *)&pSMBr->ByteCount;
> 
>-		
> 	data_offset = le32_to_cpu(pSMBr->DataOffset);
> 	data_count = le32_to_cpu(pSMBr->DataCount);
>-        parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
>+	parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
> 	parm_count = le32_to_cpu(pSMBr->ParameterCount);
> 
> 	*ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
> 	*ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
> 
> 	/* should we also check that parm and data areas do not overlap? */
>-	if(*ppparm > end_of_smb) {
>-		cFYI(1,("parms start after end of smb"));
>+	if (*ppparm > end_of_smb) {
>+		cFYI(1, ("parms start after end of smb"));
> 		return -EINVAL;
>-	} else if(parm_count + *ppparm > end_of_smb) {
>-		cFYI(1,("parm end after end of smb"));
>+	} else if (parm_count + *ppparm > end_of_smb) {
>+		cFYI(1, ("parm end after end of smb"));
> 		return -EINVAL;
>-	} else if(*ppdata > end_of_smb) {
>-		cFYI(1,("data starts after end of smb"));
>+	} else if (*ppdata > end_of_smb) {
>+		cFYI(1, ("data starts after end of smb"));
> 		return -EINVAL;
>-	} else if(data_count + *ppdata > end_of_smb) {
>-		cFYI(1,("data %p + count %d (%p) ends after end of smb %p start %p",
>-			*ppdata, data_count, (data_count + *ppdata), end_of_smb, pSMBr));  /* BB FIXME */
>+	} else if (data_count + *ppdata > end_of_smb) {
>+		cFYI(1, ("data %p + count %d (%p) ends after end of smb %p start %p",
>+			*ppdata, data_count, (data_count + *ppdata),
>+			end_of_smb, pSMBr));
> 		return -EINVAL;
>-	} else if(parm_count + data_count > pSMBr->ByteCount) {
>-		cFYI(1,("parm count and data count larger than SMB"));
>+	} else if (parm_count + data_count > pSMBr->ByteCount) {
>+		cFYI(1, ("parm count and data count larger than SMB"));
> 		return -EINVAL;
> 	}
> 	return 0;
>@@ -2370,14 +2568,14 @@ validate_ntransact(char * buf, char ** ppparm, char ** ppdata,
> int
> CIFSSMBQueryReparseLinkInfo(const int xid, struct cifsTconInfo *tcon,
> 			const unsigned char *searchName,
>-			char *symlinkinfo, const int buflen,__u16 fid,
>+			char *symlinkinfo, const int buflen, __u16 fid,
> 			const struct nls_table *nls_codepage)
> {
> 	int rc = 0;
> 	int bytes_returned;
> 	int name_len;
>-	struct smb_com_transaction_ioctl_req * pSMB;
>-	struct smb_com_transaction_ioctl_rsp * pSMBr;
>+	struct smb_com_transaction_ioctl_req *pSMB;
>+	struct smb_com_transaction_ioctl_rsp *pSMBr;
> 
> 	cFYI(1, ("In Windows reparse style QueryLink for path %s", searchName));
> 	rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
>@@ -2416,47 +2614,53 @@ CIFSSMBQueryReparseLinkInfo(const int xid, struct cifsTconInfo *tcon,
> 		/* BB also check enough total bytes returned */
> 			rc = -EIO;	/* bad smb */
> 		else {
>-			if(data_count && (data_count < 2048)) {
>-				char * end_of_smb = 2 /* sizeof byte count */ +
>+			if (data_count && (data_count < 2048)) {
>+				char *end_of_smb = 2 /* sizeof byte count */ +
> 						pSMBr->ByteCount +
> 						(char *)&pSMBr->ByteCount;
> 
>-				struct reparse_data * reparse_buf = (struct reparse_data *)
>-					((char *)&pSMBr->hdr.Protocol + data_offset);
>-				if((char*)reparse_buf >= end_of_smb) {
>+				struct reparse_data *reparse_buf =
>+						(struct reparse_data *)
>+						((char *)&pSMBr->hdr.Protocol
>+								 + data_offset);
>+				if ((char *)reparse_buf >= end_of_smb) {
> 					rc = -EIO;
> 					goto qreparse_out;
> 				}
>-				if((reparse_buf->LinkNamesBuf + 
>+				if ((reparse_buf->LinkNamesBuf +
> 					reparse_buf->TargetNameOffset +
> 					reparse_buf->TargetNameLen) >
> 						end_of_smb) {
>-					cFYI(1,("reparse buf extended beyond SMB"));
>+					cFYI(1, ("reparse buf beyond SMB"));
> 					rc = -EIO;
> 					goto qreparse_out;
> 				}
>-				
>+
> 				if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
> 					name_len = UniStrnlen((wchar_t *)
>-							(reparse_buf->LinkNamesBuf + 
>-							reparse_buf->TargetNameOffset),
>-							min(buflen/2, reparse_buf->TargetNameLen / 2)); 
>+						(reparse_buf->LinkNamesBuf +
>+						reparse_buf->TargetNameOffset),
>+						min(buflen/2,
>+						reparse_buf->TargetNameLen / 2));
> 					cifs_strfromUCS_le(symlinkinfo,
>-						(__le16 *) (reparse_buf->LinkNamesBuf + 
>+						(__le16 *) (reparse_buf->LinkNamesBuf +
> 						reparse_buf->TargetNameOffset),
> 						name_len, nls_codepage);
> 				} else { /* ASCII names */
>-					strncpy(symlinkinfo,reparse_buf->LinkNamesBuf + 
>-						reparse_buf->TargetNameOffset, 
>-						min_t(const int, buflen, reparse_buf->TargetNameLen));
>+					strncpy(symlinkinfo,
>+						reparse_buf->LinkNamesBuf +
>+						reparse_buf->TargetNameOffset,
>+						min_t(const int, buflen,
>+						   reparse_buf->TargetNameLen));
> 				}
> 			} else {
> 				rc = -EIO;
>-				cFYI(1,("Invalid return data count on get reparse info ioctl"));
>+				cFYI(1, ("Invalid return data count on "
>+					 "get reparse info ioctl"));
> 			}
> 			symlinkinfo[buflen] = 0; /* just in case so the caller
> 					does not go off the end of the buffer */
>-			cFYI(1,("readlink result - %s",symlinkinfo));
>+			cFYI(1, ("readlink result - %s", symlinkinfo));
> 		}
> 	}
> qreparse_out:
>@@ -2467,11 +2671,13 @@ qreparse_out:
> 
> 	return rc;
> }
>+
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
> #ifdef CONFIG_CIFS_POSIX
> 
> /*Convert an Access Control Entry from wire format to local POSIX xattr format*/
>-static void cifs_convert_ace(posix_acl_xattr_entry * ace, struct cifs_posix_ace * cifs_ace)
>+static void cifs_convert_ace(posix_acl_xattr_entry *ace,
>+			     struct cifs_posix_ace *cifs_ace)
> {
> 	/* u8 cifs fields do not need le conversion */
> 	ace->e_perm = cpu_to_le16(cifs_ace->cifs_e_perm);
>@@ -2483,30 +2689,31 @@ static void cifs_convert_ace(posix_acl_xattr_entry * ace, struct cifs_posix_ace
> }
> 
> /* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
>-static int cifs_copy_posix_acl(char * trgt,char * src, const int buflen,
>-				const int acl_type,const int size_of_data_area)
>+static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen,
>+			       const int acl_type, const int size_of_data_area)
> {
> 	int size =  0;
> 	int i;
> 	__u16 count;
>-	struct cifs_posix_ace * pACE;
>-	struct cifs_posix_acl * cifs_acl = (struct cifs_posix_acl *)src;
>-	posix_acl_xattr_header * local_acl = (posix_acl_xattr_header *)trgt;
>+	struct cifs_posix_ace *pACE;
>+	struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src;
>+	posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)trgt;
> 
> 	if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
> 		return -EOPNOTSUPP;
> 
>-	if(acl_type & ACL_TYPE_ACCESS) {
>+	if (acl_type & ACL_TYPE_ACCESS) {
> 		count = le16_to_cpu(cifs_acl->access_entry_count);
> 		pACE = &cifs_acl->ace_array[0];
> 		size = sizeof(struct cifs_posix_acl);
> 		size += sizeof(struct cifs_posix_ace) * count;
> 		/* check if we would go beyond end of SMB */
>-		if(size_of_data_area < size) {
>-			cFYI(1,("bad CIFS POSIX ACL size %d vs. %d",size_of_data_area,size));
>+		if (size_of_data_area < size) {
>+			cFYI(1, ("bad CIFS POSIX ACL size %d vs. %d",
>+				size_of_data_area, size));
> 			return -EINVAL;
> 		}
>-	} else if(acl_type & ACL_TYPE_DEFAULT) {
>+	} else if (acl_type & ACL_TYPE_DEFAULT) {
> 		count = le16_to_cpu(cifs_acl->access_entry_count);
> 		size = sizeof(struct cifs_posix_acl);
> 		size += sizeof(struct cifs_posix_ace) * count;
>@@ -2515,7 +2722,7 @@ static int cifs_copy_posix_acl(char * trgt,char * src, const int buflen,
> 		count = le16_to_cpu(cifs_acl->default_entry_count);
> 		size += sizeof(struct cifs_posix_ace) * count;
> 		/* check if we would go beyond end of SMB */
>-		if(size_of_data_area < size)
>+		if (size_of_data_area < size)
> 			return -EINVAL;
> 	} else {
> 		/* illegal type */
>@@ -2523,76 +2730,77 @@ static int cifs_copy_posix_acl(char * trgt,char * src, const int buflen,
> 	}
> 
> 	size = posix_acl_xattr_size(count);
>-	if((buflen == 0) || (local_acl == NULL)) {
>-		/* used to query ACL EA size */				
>-	} else if(size > buflen) {
>+	if ((buflen == 0) || (local_acl == NULL)) {
>+		/* used to query ACL EA size */
>+	} else if (size > buflen) {
> 		return -ERANGE;
> 	} else /* buffer big enough */ {
> 		local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
>-		for(i = 0;i < count ;i++) {
>-			cifs_convert_ace(&local_acl->a_entries[i],pACE);
>-			pACE ++;
>+		for (i = 0; i < count ; i++) {
>+			cifs_convert_ace(&local_acl->a_entries[i], pACE);
>+			pACE++;
> 		}
> 	}
> 	return size;
> }
> 
>-static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace * cifs_ace,
>-			const posix_acl_xattr_entry * local_ace)
>+static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace *cifs_ace,
>+				     const posix_acl_xattr_entry *local_ace)
> {
> 	__u16 rc = 0; /* 0 = ACL converted ok */
> 
> 	cifs_ace->cifs_e_perm = le16_to_cpu(local_ace->e_perm);
> 	cifs_ace->cifs_e_tag =  le16_to_cpu(local_ace->e_tag);
> 	/* BB is there a better way to handle the large uid? */
>-	if(local_ace->e_id == cpu_to_le32(-1)) {
>+	if (local_ace->e_id == cpu_to_le32(-1)) {
> 	/* Probably no need to le convert -1 on any arch but can not hurt */
> 		cifs_ace->cifs_uid = cpu_to_le64(-1);
>-	} else 
>+	} else
> 		cifs_ace->cifs_uid = cpu_to_le64(le32_to_cpu(local_ace->e_id));
>-        /*cFYI(1,("perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id));*/
>+	/*cFYI(1,("perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id));*/
> 	return rc;
> }
> 
> /* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
>-static __u16 ACL_to_cifs_posix(char * parm_data,const char * pACL,const int buflen,
>-		const int acl_type)
>+static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL,
>+			       const int buflen, const int acl_type)
> {
> 	__u16 rc = 0;
>-        struct cifs_posix_acl * cifs_acl = (struct cifs_posix_acl *)parm_data;
>-        posix_acl_xattr_header * local_acl = (posix_acl_xattr_header *)pACL;
>+	struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data;
>+	posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)pACL;
> 	int count;
> 	int i;
> 
>-	if((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
>+	if ((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
> 		return 0;
> 
> 	count = posix_acl_xattr_count((size_t)buflen);
>-	cFYI(1,("setting acl with %d entries from buf of length %d and version of %d",
>+	cFYI(1, ("setting acl with %d entries from buf of length %d and "
>+		"version of %d",
> 		count, buflen, le32_to_cpu(local_acl->a_version)));
>-	if(le32_to_cpu(local_acl->a_version) != 2) {
>-		cFYI(1,("unknown POSIX ACL version %d",
>+	if (le32_to_cpu(local_acl->a_version) != 2) {
>+		cFYI(1, ("unknown POSIX ACL version %d",
> 		     le32_to_cpu(local_acl->a_version)));
> 		return 0;
> 	}
> 	cifs_acl->version = cpu_to_le16(1);
>-	if(acl_type == ACL_TYPE_ACCESS) 
>+	if (acl_type == ACL_TYPE_ACCESS)
> 		cifs_acl->access_entry_count = cpu_to_le16(count);
>-	else if(acl_type == ACL_TYPE_DEFAULT)
>+	else if (acl_type == ACL_TYPE_DEFAULT)
> 		cifs_acl->default_entry_count = cpu_to_le16(count);
> 	else {
>-		cFYI(1,("unknown ACL type %d",acl_type));
>+		cFYI(1, ("unknown ACL type %d", acl_type));
> 		return 0;
> 	}
>-	for(i=0;i<count;i++) {
>+	for (i = 0; i < count; i++) {
> 		rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
> 					&local_acl->a_entries[i]);
>-		if(rc != 0) {
>+		if (rc != 0) {
> 			/* ACE not converted */
> 			break;
> 		}
> 	}
>-	if(rc == 0) {
>+	if (rc == 0) {
> 		rc = (__u16)(count * sizeof(struct cifs_posix_ace));
> 		rc += sizeof(struct cifs_posix_acl);
> 		/* BB add check to make sure ACL does not overflow SMB */
>@@ -2602,9 +2810,9 @@ static __u16 ACL_to_cifs_posix(char * parm_data,const char * pACL,const int bufl
> 
> int
> CIFSSMBGetPosixACL(const int xid, struct cifsTconInfo *tcon,
>-                        const unsigned char *searchName,
>-                        char *acl_inf, const int buflen, const int acl_type,
>-                        const struct nls_table *nls_codepage, int remap)
>+		   const unsigned char *searchName,
>+		   char *acl_inf, const int buflen, const int acl_type,
>+		   const struct nls_table *nls_codepage, int remap)
> {
> /* SMB_QUERY_POSIX_ACL */
> 	TRANSACTION2_QPI_REQ *pSMB = NULL;
>@@ -2613,7 +2821,7 @@ CIFSSMBGetPosixACL(const int xid, struct cifsTconInfo *tcon,
> 	int bytes_returned;
> 	int name_len;
> 	__u16 params, byte_count;
>-                                                                                                                                             
>+
> 	cFYI(1, ("In GetPosixACL (Unix) for path %s", searchName));
> 
> queryAclRetry:
>@@ -2621,16 +2829,16 @@ queryAclRetry:
> 		(void **) &pSMBr);
> 	if (rc)
> 		return rc;
>-                                                                                                                                             
>+
> 	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
> 		name_len =
>-			cifsConvertToUCS((__le16 *) pSMB->FileName, searchName, 
>+			cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
> 					 PATH_MAX, nls_codepage, remap);
> 		name_len++;     /* trailing null */
> 		name_len *= 2;
> 		pSMB->FileName[name_len] = 0;
> 		pSMB->FileName[name_len+1] = 0;
>-	} else {                /* BB improve the check for buffer overruns BB */
>+	} else {	/* BB improve the check for buffer overruns BB */
> 		name_len = strnlen(searchName, PATH_MAX);
> 		name_len++;     /* trailing null */
> 		strncpy(pSMB->FileName, searchName, name_len);
>@@ -2639,7 +2847,7 @@ queryAclRetry:
> 	params = 2 /* level */  + 4 /* rsrvd */  + name_len /* incl null */ ;
> 	pSMB->TotalDataCount = 0;
> 	pSMB->MaxParameterCount = cpu_to_le16(2);
>-        /* BB find exact max data count below from sess structure BB */
>+	/* BB find exact max data count below from sess structure BB */
> 	pSMB->MaxDataCount = cpu_to_le16(4000);
> 	pSMB->MaxSetupCount = 0;
> 	pSMB->Reserved = 0;
>@@ -2647,7 +2855,8 @@ queryAclRetry:
> 	pSMB->Timeout = 0;
> 	pSMB->Reserved2 = 0;
> 	pSMB->ParameterOffset = cpu_to_le16(
>-		offsetof(struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
>+		offsetof(struct smb_com_transaction2_qpi_req,
>+			 InformationLevel) - 4);
> 	pSMB->DataCount = 0;
> 	pSMB->DataOffset = 0;
> 	pSMB->SetupCount = 1;
>@@ -2668,7 +2877,7 @@ queryAclRetry:
> 		cFYI(1, ("Send error in Query POSIX ACL = %d", rc));
> 	} else {
> 		/* decode response */
>- 
>+
> 		rc = validate_t2((struct smb_t2_rsp *)pSMBr);
> 		if (rc || (pSMBr->ByteCount < 2))
> 		/* BB also check enough total bytes returned */
>@@ -2678,7 +2887,7 @@ queryAclRetry:
> 			__u16 count = le16_to_cpu(pSMBr->t2.DataCount);
> 			rc = cifs_copy_posix_acl(acl_inf,
> 				(char *)&pSMBr->hdr.Protocol+data_offset,
>-				buflen,acl_type,count);
>+				buflen, acl_type, count);
> 		}
> 	}
> 	cifs_buf_release(pSMB);
>@@ -2689,10 +2898,10 @@ queryAclRetry:
> 
> int
> CIFSSMBSetPosixACL(const int xid, struct cifsTconInfo *tcon,
>-                        const unsigned char *fileName,
>-                        const char *local_acl, const int buflen, 
>-			const int acl_type,
>-                        const struct nls_table *nls_codepage, int remap)
>+		   const unsigned char *fileName,
>+		   const char *local_acl, const int buflen,
>+		   const int acl_type,
>+		   const struct nls_table *nls_codepage, int remap)
> {
> 	struct smb_com_transaction2_spi_req *pSMB = NULL;
> 	struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
>@@ -2705,16 +2914,16 @@ CIFSSMBSetPosixACL(const int xid, struct cifsTconInfo *tcon,
> 	cFYI(1, ("In SetPosixACL (Unix) for path %s", fileName));
> setAclRetry:
> 	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
>-                      (void **) &pSMBr);
>+		      (void **) &pSMBr);
> 	if (rc)
> 		return rc;
> 	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
> 		name_len =
>-			cifsConvertToUCS((__le16 *) pSMB->FileName, fileName, 
>+			cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
> 				      PATH_MAX, nls_codepage, remap);
> 		name_len++;     /* trailing null */
> 		name_len *= 2;
>-	} else {                /* BB improve the check for buffer overruns BB */
>+	} else {	/* BB improve the check for buffer overruns BB */
> 		name_len = strnlen(fileName, PATH_MAX);
> 		name_len++;     /* trailing null */
> 		strncpy(pSMB->FileName, fileName, name_len);
>@@ -2728,15 +2937,15 @@ setAclRetry:
> 	pSMB->Timeout = 0;
> 	pSMB->Reserved2 = 0;
> 	param_offset = offsetof(struct smb_com_transaction2_spi_req,
>-                                     InformationLevel) - 4;
>+				InformationLevel) - 4;
> 	offset = param_offset + params;
> 	parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
> 	pSMB->ParameterOffset = cpu_to_le16(param_offset);
> 
> 	/* convert to on the wire format for POSIX ACL */
>-	data_count = ACL_to_cifs_posix(parm_data,local_acl,buflen,acl_type);
>+	data_count = ACL_to_cifs_posix(parm_data, local_acl, buflen, acl_type);
> 
>-	if(data_count == 0) {
>+	if (data_count == 0) {
> 		rc = -EOPNOTSUPP;
> 		goto setACLerrorExit;
> 	}
>@@ -2754,7 +2963,7 @@ setAclRetry:
> 	pSMB->hdr.smb_buf_length += byte_count;
> 	pSMB->ByteCount = cpu_to_le16(byte_count);
> 	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
>-                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
>+			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
> 	if (rc) {
> 		cFYI(1, ("Set POSIX ACL returned %d", rc));
> 	}
>@@ -2769,96 +2978,97 @@ setACLerrorExit:
> /* BB fix tabs in this function FIXME BB */
> int
> CIFSGetExtAttr(const int xid, struct cifsTconInfo *tcon,
>-                const int netfid, __u64 * pExtAttrBits, __u64 *pMask)
>+	       const int netfid, __u64 * pExtAttrBits, __u64 *pMask)
> {
>-        int rc = 0;
>-        struct smb_t2_qfi_req *pSMB = NULL;
>-        struct smb_t2_qfi_rsp *pSMBr = NULL;
>-        int bytes_returned;
>-        __u16 params, byte_count;
>+	int rc = 0;
>+	struct smb_t2_qfi_req *pSMB = NULL;
>+	struct smb_t2_qfi_rsp *pSMBr = NULL;
>+	int bytes_returned;
>+	__u16 params, byte_count;
> 
>-        cFYI(1,("In GetExtAttr"));
>-        if(tcon == NULL)
>-                return -ENODEV;
>+	cFYI(1, ("In GetExtAttr"));
>+	if (tcon == NULL)
>+		return -ENODEV;
> 
> GetExtAttrRetry:
>-        rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
>-                      (void **) &pSMBr);
>-        if (rc)
>-                return rc;
>-
>-        params = 2 /* level */ +2 /* fid */;
>-        pSMB->t2.TotalDataCount = 0;
>-        pSMB->t2.MaxParameterCount = cpu_to_le16(4);
>-        /* BB find exact max data count below from sess structure BB */
>-        pSMB->t2.MaxDataCount = cpu_to_le16(4000);
>-        pSMB->t2.MaxSetupCount = 0;
>-        pSMB->t2.Reserved = 0;
>-        pSMB->t2.Flags = 0;
>-        pSMB->t2.Timeout = 0;
>-        pSMB->t2.Reserved2 = 0;
>-        pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
>-			Fid) - 4);
>-        pSMB->t2.DataCount = 0;
>-        pSMB->t2.DataOffset = 0;
>-        pSMB->t2.SetupCount = 1;
>-        pSMB->t2.Reserved3 = 0;
>-        pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
>-        byte_count = params + 1 /* pad */ ;
>-        pSMB->t2.TotalParameterCount = cpu_to_le16(params);
>-        pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
>-        pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
>-        pSMB->Pad = 0;
>+	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
>+			(void **) &pSMBr);
>+	if (rc)
>+		return rc;
>+
>+	params = 2 /* level */ +2 /* fid */;
>+	pSMB->t2.TotalDataCount = 0;
>+	pSMB->t2.MaxParameterCount = cpu_to_le16(4);
>+	/* BB find exact max data count below from sess structure BB */
>+	pSMB->t2.MaxDataCount = cpu_to_le16(4000);
>+	pSMB->t2.MaxSetupCount = 0;
>+	pSMB->t2.Reserved = 0;
>+	pSMB->t2.Flags = 0;
>+	pSMB->t2.Timeout = 0;
>+	pSMB->t2.Reserved2 = 0;
>+	pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
>+					       Fid) - 4);
>+	pSMB->t2.DataCount = 0;
>+	pSMB->t2.DataOffset = 0;
>+	pSMB->t2.SetupCount = 1;
>+	pSMB->t2.Reserved3 = 0;
>+	pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
>+	byte_count = params + 1 /* pad */ ;
>+	pSMB->t2.TotalParameterCount = cpu_to_le16(params);
>+	pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
>+	pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
>+	pSMB->Pad = 0;
> 	pSMB->Fid = netfid;
>-        pSMB->hdr.smb_buf_length += byte_count;
>-        pSMB->t2.ByteCount = cpu_to_le16(byte_count);
>-
>-        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
>-                (struct smb_hdr *) pSMBr, &bytes_returned, 0);
>-        if (rc) {
>-                cFYI(1, ("error %d in GetExtAttr", rc));
>-        } else {
>-                /* decode response */
>-                rc = validate_t2((struct smb_t2_rsp *)pSMBr);
>-                if (rc || (pSMBr->ByteCount < 2))
>-                /* BB also check enough total bytes returned */
>-                        /* If rc should we check for EOPNOSUPP and
>-                        disable the srvino flag? or in caller? */
>-                        rc = -EIO;      /* bad smb */
>-                else {
>-                        __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
>-                        __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
>-                        struct file_chattr_info * pfinfo;
>-                        /* BB Do we need a cast or hash here ? */
>-                        if(count != 16) {
>-                                cFYI(1, ("Illegal size ret in GetExtAttr"));
>-                                rc = -EIO;
>-                                goto GetExtAttrOut;
>-                        }
>-                        pfinfo = (struct file_chattr_info *)
>-                                (data_offset + (char *) &pSMBr->hdr.Protocol);
>-                        *pExtAttrBits = le64_to_cpu(pfinfo->mode);
>+	pSMB->hdr.smb_buf_length += byte_count;
>+	pSMB->t2.ByteCount = cpu_to_le16(byte_count);
>+
>+	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
>+			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
>+	if (rc) {
>+		cFYI(1, ("error %d in GetExtAttr", rc));
>+	} else {
>+		/* decode response */
>+		rc = validate_t2((struct smb_t2_rsp *)pSMBr);
>+		if (rc || (pSMBr->ByteCount < 2))
>+		/* BB also check enough total bytes returned */
>+			/* If rc should we check for EOPNOSUPP and
>+			   disable the srvino flag? or in caller? */
>+			rc = -EIO;      /* bad smb */
>+		else {
>+			__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
>+			__u16 count = le16_to_cpu(pSMBr->t2.DataCount);
>+			struct file_chattr_info *pfinfo;
>+			/* BB Do we need a cast or hash here ? */
>+			if (count != 16) {
>+				cFYI(1, ("Illegal size ret in GetExtAttr"));
>+				rc = -EIO;
>+				goto GetExtAttrOut;
>+			}
>+			pfinfo = (struct file_chattr_info *)
>+				 (data_offset + (char *) &pSMBr->hdr.Protocol);
>+			*pExtAttrBits = le64_to_cpu(pfinfo->mode);
> 			*pMask = le64_to_cpu(pfinfo->mask);
>-                }
>-        }
>+		}
>+	}
> GetExtAttrOut:
>-        cifs_buf_release(pSMB);
>-        if (rc == -EAGAIN)
>-                goto GetExtAttrRetry;
>-        return rc;
>+	cifs_buf_release(pSMB);
>+	if (rc == -EAGAIN)
>+		goto GetExtAttrRetry;
>+	return rc;
> }
> 
>-
> #endif /* CONFIG_POSIX */
> #endif /* if version > 2.5 */
> 
> /* security id for everyone */
>-const struct cifs_sid sid_everyone = {1, 1, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0}};
>+static const struct cifs_sid sid_everyone =
>+		{1, 1, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0}};
> /* group users */
>-const struct cifs_sid sid_user = {1, 2 , {0, 0, 0, 0, 0, 5}, {32, 545, 0, 0}};
>+static const struct cifs_sid sid_user =
>+		{1, 2 , {0, 0, 0, 0, 0, 5}, {32, 545, 0, 0}};
> 
> /* Convert CIFS ACL to POSIX form */
>-static int parse_sec_desc(struct cifs_sid * psec_desc, int acl_len)
>+static int parse_sec_desc(struct cifs_sid *psec_desc, int acl_len)
> {
> 	return 0;
> }
>@@ -2866,7 +3076,7 @@ static int parse_sec_desc(struct cifs_sid * psec_desc, int acl_len)
> /* Get Security Descriptor (by handle) from remote server for a file or dir */
> int
> CIFSSMBGetCIFSACL(const int xid, struct cifsTconInfo *tcon, __u16 fid,
>-         /*  BB fix up return info */ char *acl_inf, const int buflen, 
>+		/* BB fix up return info */ char *acl_inf, const int buflen,
> 		  const int acl_type /* ACCESS/DEFAULT not sure implication */)
> {
> 	int rc = 0;
>@@ -2876,7 +3086,7 @@ CIFSSMBGetCIFSACL(const int xid, struct cifsTconInfo *tcon, __u16 fid,
> 
> 	cFYI(1, ("GetCifsACL"));
> 
>-	rc = smb_init_ntransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0, 
>+	rc = smb_init_ntransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
> 			8 /* parm len */, tcon, (void **) &pSMB);
> 	if (rc)
> 		return rc;
>@@ -2897,23 +3107,23 @@ CIFSSMBGetCIFSACL(const int xid, struct cifsTconInfo *tcon, __u16 fid,
> 	if (rc) {
> 		cFYI(1, ("Send error in QuerySecDesc = %d", rc));
> 	} else {                /* decode response */
>-		struct cifs_sid * psec_desc;
>+		struct cifs_sid *psec_desc;
> 		__le32 * parm;
> 		int parm_len;
> 		int data_len;
> 		int acl_len;
>-		struct smb_com_ntransact_rsp * pSMBr;
>+		struct smb_com_ntransact_rsp *pSMBr;
> 
> /* validate_nttransact */
>-		rc = validate_ntransact(iov[0].iov_base, (char **)&parm, 
>+		rc = validate_ntransact(iov[0].iov_base, (char **)&parm,
> 					(char **)&psec_desc,
> 					&parm_len, &data_len);
>-		
>-		if(rc)
>+		if (rc)
> 			goto qsec_out;
> 		pSMBr = (struct smb_com_ntransact_rsp *)iov[0].iov_base;
> 
>-		cERROR(1,("smb %p parm %p data %p",pSMBr,parm,psec_desc));  /* BB removeme BB */
>+		cERROR(1, ("smb %p parm %p data %p",
>+			  pSMBr, parm, psec_desc));  /* BB removeme BB */
> 
> 		if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
> 			rc = -EIO;      /* bad smb */
>@@ -2923,14 +3133,14 @@ CIFSSMBGetCIFSACL(const int xid, struct cifsTconInfo *tcon, __u16 fid,
> /* BB check that data area is minimum length and as big as acl_len */
> 
> 		acl_len = le32_to_cpu(*(__le32 *)parm);
>-		/* BB check if(acl_len > bufsize) */
>+		/* BB check if (acl_len > bufsize) */
> 
> 		parse_sec_desc(psec_desc, acl_len);
> 	}
> qsec_out:
>-	if(buf_type == CIFS_SMALL_BUFFER)
>+	if (buf_type == CIFS_SMALL_BUFFER)
> 		cifs_small_buf_release(iov[0].iov_base);
>-	else if(buf_type == CIFS_LARGE_BUFFER)
>+	else if (buf_type == CIFS_LARGE_BUFFER)
> 		cifs_buf_release(iov[0].iov_base);
> /*	cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
> 	return rc;
>@@ -2939,9 +3149,9 @@ qsec_out:
> /* Legacy Query Path Information call for lookup to old servers such
>    as Win9x/WinME */
> int SMBQueryInformation(const int xid, struct cifsTconInfo *tcon,
>-                 const unsigned char *searchName,
>-                 FILE_ALL_INFO * pFinfo,
>-                 const struct nls_table *nls_codepage, int remap)
>+			const unsigned char *searchName,
>+			FILE_ALL_INFO *pFinfo,
>+			const struct nls_table *nls_codepage, int remap)
> {
> 	QUERY_INFORMATION_REQ * pSMB;
> 	QUERY_INFORMATION_RSP * pSMBr;
>@@ -2949,31 +3159,31 @@ int SMBQueryInformation(const int xid, struct cifsTconInfo *tcon,
> 	int bytes_returned;
> 	int name_len;
> 
>-	cFYI(1, ("In SMBQPath path %s", searchName)); 
>+	cFYI(1, ("In SMBQPath path %s", searchName));
> QInfRetry:
> 	rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
>-                      (void **) &pSMBr);
>+		      (void **) &pSMBr);
> 	if (rc)
> 		return rc;
> 
> 	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
> 		name_len =
>-                    cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
>-                                     PATH_MAX, nls_codepage, remap);
>+			cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
>+					PATH_MAX, nls_codepage, remap);
> 		name_len++;     /* trailing null */
> 		name_len *= 2;
>-	} else {               
>+	} else {
> 		name_len = strnlen(searchName, PATH_MAX);
> 		name_len++;     /* trailing null */
> 		strncpy(pSMB->FileName, searchName, name_len);
> 	}
> 	pSMB->BufferFormat = 0x04;
>-	name_len++; /* account for buffer type byte */	
>+	name_len++; /* account for buffer type byte */
> 	pSMB->hdr.smb_buf_length += (__u16) name_len;
> 	pSMB->ByteCount = cpu_to_le16(name_len);
> 
> 	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
>-                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
>+			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
> 	if (rc) {
> 		cFYI(1, ("Send error in QueryInfo = %d", rc));
> 	} else if (pFinfo) {            /* decode response */
>@@ -3034,17 +3244,17 @@ QPathInfoRetry:
> 
> 	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
> 		name_len =
>-		    cifsConvertToUCS((__le16 *) pSMB->FileName, searchName, 
>+		    cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
> 				     PATH_MAX, nls_codepage, remap);
> 		name_len++;	/* trailing null */
> 		name_len *= 2;
>-	} else {		/* BB improve the check for buffer overruns BB */
>+	} else {	/* BB improve the check for buffer overruns BB */
> 		name_len = strnlen(searchName, PATH_MAX);
> 		name_len++;	/* trailing null */
> 		strncpy(pSMB->FileName, searchName, name_len);
> 	}
> 
>-	params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
>+	params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
> 	pSMB->TotalDataCount = 0;
> 	pSMB->MaxParameterCount = cpu_to_le16(2);
> 	pSMB->MaxDataCount = cpu_to_le16(4000);	/* BB find exact max SMB PDU from sess structure BB */
>@@ -3054,7 +3264,7 @@ QPathInfoRetry:
> 	pSMB->Timeout = 0;
> 	pSMB->Reserved2 = 0;
> 	pSMB->ParameterOffset = cpu_to_le16(offsetof(
>-        struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
>+	struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
> 	pSMB->DataCount = 0;
> 	pSMB->DataOffset = 0;
> 	pSMB->SetupCount = 1;
>@@ -3063,7 +3273,7 @@ QPathInfoRetry:
> 	byte_count = params + 1 /* pad */ ;
> 	pSMB->TotalParameterCount = cpu_to_le16(params);
> 	pSMB->ParameterCount = pSMB->TotalParameterCount;
>-	if(legacy)
>+	if (legacy)
> 		pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
> 	else
> 		pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
>@@ -3080,16 +3290,18 @@ QPathInfoRetry:
> 
> 		if (rc) /* BB add auto retry on EOPNOTSUPP? */
> 			rc = -EIO;
>-		else if (!legacy && (pSMBr->ByteCount < 40)) 
>+		else if (!legacy && (pSMBr->ByteCount < 40))
> 			rc = -EIO;	/* bad smb */
>-		else if(legacy && (pSMBr->ByteCount < 24))
>-			rc = -EIO;  /* 24 or 26 expected but we do not read last field */
>-		else if (pFindData){
>+		else if (legacy && (pSMBr->ByteCount < 24))
>+			rc = -EIO;  /* 24 or 26 expected but we do not read
>+					last field */
>+		else if (pFindData) {
> 			int size;
> 			__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
>-			if(legacy) /* we do not read the last field, EAsize, fortunately
>-					   since it varies by subdialect and on Set vs. Get, is  
>-					   two bytes or 4 bytes depending but we don't care here */
>+			if (legacy) /* we do not read the last field, EAsize,
>+				       fortunately since it varies by subdialect
>+				       and on Set vs. Get, is two bytes or 4
>+				       bytes depending but we don't care here */
> 				size = sizeof(FILE_INFO_STANDARD);
> 			else
> 				size = sizeof(FILE_ALL_INFO);
>@@ -3133,24 +3345,24 @@ UnixQPathInfoRetry:
> 				  PATH_MAX, nls_codepage, remap);
> 		name_len++;	/* trailing null */
> 		name_len *= 2;
>-	} else {		/* BB improve the check for buffer overruns BB */
>+	} else {	/* BB improve the check for buffer overruns BB */
> 		name_len = strnlen(searchName, PATH_MAX);
> 		name_len++;	/* trailing null */
> 		strncpy(pSMB->FileName, searchName, name_len);
> 	}
> 
>-	params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
>+	params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
> 	pSMB->TotalDataCount = 0;
> 	pSMB->MaxParameterCount = cpu_to_le16(2);
> 	/* BB find exact max SMB PDU from sess structure BB */
>-	pSMB->MaxDataCount = cpu_to_le16(4000); 
>+	pSMB->MaxDataCount = cpu_to_le16(4000);
> 	pSMB->MaxSetupCount = 0;
> 	pSMB->Reserved = 0;
> 	pSMB->Flags = 0;
> 	pSMB->Timeout = 0;
> 	pSMB->Reserved2 = 0;
> 	pSMB->ParameterOffset = cpu_to_le16(offsetof(
>-        struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
>+	struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
> 	pSMB->DataCount = 0;
> 	pSMB->DataOffset = 0;
> 	pSMB->SetupCount = 1;
>@@ -3210,12 +3422,11 @@ findUniqueRetry:
> 
> 	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
> 		name_len =
>-		    cifsConvertToUCS((__le16 *) pSMB->FileName, searchName, PATH_MAX
>-				  /* find define for this maxpathcomponent */
>-				  , nls_codepage);
>+		    cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
>+				     PATH_MAX, nls_codepage);
> 		name_len++;	/* trailing null */
> 		name_len *= 2;
>-	} else {		/* BB improve the check for buffer overruns BB */
>+	} else {	/* BB improve the check for buffer overruns BB */
> 		name_len = strnlen(searchName, PATH_MAX);
> 		name_len++;	/* trailing null */
> 		strncpy(pSMB->FileName, searchName, name_len);
>@@ -3231,7 +3442,7 @@ findUniqueRetry:
> 	pSMB->Timeout = 0;
> 	pSMB->Reserved2 = 0;
> 	pSMB->ParameterOffset = cpu_to_le16(
>-         offsetof(struct smb_com_transaction2_ffirst_req,InformationLevel) - 4);
>+	 offsetof(struct smb_com_transaction2_ffirst_req, InformationLevel)-4);
> 	pSMB->DataCount = 0;
> 	pSMB->DataOffset = 0;
> 	pSMB->SetupCount = 1;	/* one byte, no need to le convert */
>@@ -3271,10 +3482,10 @@ findUniqueRetry:
> /* xid, tcon, searchName and codepage are input parms, rest are returned */
> int
> CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
>-	      const char *searchName, 
>+	      const char *searchName,
> 	      const struct nls_table *nls_codepage,
>-	      __u16 *	pnetfid,
>-	      struct cifs_search_info * psrch_inf, int remap, const char dirsep)
>+	      __u16 *pnetfid,
>+	      struct cifs_search_info *psrch_inf, int remap, const char dirsep)
> {
> /* level 257 SMB_ */
> 	TRANSACTION2_FFIRST_REQ *pSMB = NULL;
>@@ -3285,7 +3496,7 @@ CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
> 	int name_len;
> 	__u16 params, byte_count;
> 
>-	cFYI(1, ("In FindFirst for %s",searchName));
>+	cFYI(1, ("In FindFirst for %s", searchName));
> 
> findFirstRetry:
> 	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
>@@ -3295,7 +3506,7 @@ findFirstRetry:
> 
> 	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
> 		name_len =
>-		    cifsConvertToUCS((__le16 *) pSMB->FileName,searchName,
>+		    cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
> 				 PATH_MAX, nls_codepage, remap);
> 		/* We can not add the asterik earlier in case
> 		it got remapped to 0xF03A as if it were part of the
>@@ -3312,7 +3523,7 @@ findFirstRetry:
> 	} else {	/* BB add check for overrun of SMB buf BB */
> 		name_len = strnlen(searchName, PATH_MAX);
> /* BB fix here and in unicode clause above ie
>-		if(name_len > buffersize-header)
>+		if (name_len > buffersize-header)
> 			free buffer exit; BB */
> 		strncpy(pSMB->FileName, searchName, name_len);
> 		pSMB->FileName[name_len] = dirsep;
>@@ -3345,8 +3556,8 @@ findFirstRetry:
> 	pSMB->SearchAttributes =
> 	    cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
> 			ATTR_DIRECTORY);
>-	pSMB->SearchCount= cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
>-	pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | 
>+	pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
>+	pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END |
> 		CIFS_SEARCH_RETURN_RESUME);
> 	pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
> 
>@@ -3373,7 +3584,7 @@ findFirstRetry:
> 	} else { /* decode response */
> 		/* BB remember to free buffer if error BB */
> 		rc = validate_t2((struct smb_t2_rsp *)pSMBr);
>-		if(rc == 0) {
>+		if (rc == 0) {
> 			if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
> 				psrch_inf->unicode = TRUE;
> 			else
>@@ -3381,18 +3592,19 @@ findFirstRetry:
> 
> 			psrch_inf->ntwrk_buf_start = (char *)pSMBr;
> 			psrch_inf->smallBuf = 0;
>-			psrch_inf->srch_entries_start = 
>-				(char *) &pSMBr->hdr.Protocol + 
>+			psrch_inf->srch_entries_start =
>+				(char *) &pSMBr->hdr.Protocol +
> 					le16_to_cpu(pSMBr->t2.DataOffset);
> 			parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
> 			       le16_to_cpu(pSMBr->t2.ParameterOffset));
> 
>-			if(parms->EndofSearch)
>+			if (parms->EndofSearch)
> 				psrch_inf->endOfSearch = TRUE;
> 			else
> 				psrch_inf->endOfSearch = FALSE;
> 
>-			psrch_inf->entries_in_buffer  = le16_to_cpu(parms->SearchCount);
>+			psrch_inf->entries_in_buffer =
>+					le16_to_cpu(parms->SearchCount);
> 			psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
> 				psrch_inf->entries_in_buffer;
> 			*pnetfid = parms->SearchHandle;
>@@ -3405,7 +3617,7 @@ findFirstRetry:
> }
> 
> int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
>-            __u16 searchHandle, struct cifs_search_info * psrch_inf)
>+		 __u16 searchHandle, struct cifs_search_info *psrch_inf)
> {
> 	TRANSACTION2_FNEXT_REQ *pSMB = NULL;
> 	TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
>@@ -3417,7 +3629,7 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
> 
> 	cFYI(1, ("In FindNext"));
> 
>-	if(psrch_inf->endOfSearch == TRUE)
>+	if (psrch_inf->endOfSearch == TRUE)
> 		return -ENOENT;
> 
> 	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
>@@ -3425,12 +3637,13 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
> 	if (rc)
> 		return rc;
> 
>-	params = 14;    /* includes 2 bytes of null string, converted to LE below */
>+	params = 14; /* includes 2 bytes of null string, converted to LE below*/
> 	byte_count = 0;
> 	pSMB->TotalDataCount = 0;       /* no EAs */
> 	pSMB->MaxParameterCount = cpu_to_le16(8);
> 	pSMB->MaxDataCount =
>-            cpu_to_le16((tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
>+		cpu_to_le16((tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) &
>+				0xFFFFFF00);
> 	pSMB->MaxSetupCount = 0;
> 	pSMB->Reserved = 0;
> 	pSMB->Flags = 0;
>@@ -3446,15 +3659,6 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
> 	pSMB->SearchHandle = searchHandle;      /* always kept as le */
> 	pSMB->SearchCount =
> 		cpu_to_le16(CIFSMaxBufSize / sizeof (FILE_UNIX_INFO));
>-	/* test for Unix extensions */
>-/*	if (tcon->ses->capabilities & CAP_UNIX) {
>-		pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_UNIX);
>-		psrch_inf->info_level = SMB_FIND_FILE_UNIX;
>-	} else {
>-		pSMB->InformationLevel =
>-		   cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
>-		psrch_inf->info_level = SMB_FIND_FILE_DIRECTORY_INFO;
>-	} */
> 	pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
> 	pSMB->ResumeKey = psrch_inf->resume_key;
> 	pSMB->SearchFlags =
>@@ -3462,7 +3666,7 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
> 
> 	name_len = psrch_inf->resume_name_len;
> 	params += name_len;
>-	if(name_len < PATH_MAX) {
>+	if (name_len < PATH_MAX) {
> 		memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
> 		byte_count += name_len;
> 		/* 14 byte parm len above enough for 2 byte null terminator */
>@@ -3477,20 +3681,20 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
> 	pSMB->ParameterCount = pSMB->TotalParameterCount;
> 	pSMB->hdr.smb_buf_length += byte_count;
> 	pSMB->ByteCount = cpu_to_le16(byte_count);
>-                                                                                              
>+
> 	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
> 			(struct smb_hdr *) pSMBr, &bytes_returned, 0);
> 	cifs_stats_inc(&tcon->num_fnext);
> 	if (rc) {
> 		if (rc == -EBADF) {
> 			psrch_inf->endOfSearch = TRUE;
>-			rc = 0; /* search probably was closed at end of search above */
>+			rc = 0; /* search probably was closed at end of search*/
> 		} else
> 			cFYI(1, ("FindNext returned = %d", rc));
> 	} else {                /* decode response */
> 		rc = validate_t2((struct smb_t2_rsp *)pSMBr);
>-		
>-		if(rc == 0) {
>+
>+		if (rc == 0) {
> 			/* BB fixme add lock for file (srch_info) struct here */
> 			if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
> 				psrch_inf->unicode = TRUE;
>@@ -3501,7 +3705,7 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
> 			parms = (T2_FNEXT_RSP_PARMS *)response_data;
> 			response_data = (char *)&pSMBr->hdr.Protocol +
> 				le16_to_cpu(pSMBr->t2.DataOffset);
>-			if(psrch_inf->smallBuf)
>+			if (psrch_inf->smallBuf)
> 				cifs_small_buf_release(
> 					psrch_inf->ntwrk_buf_start);
> 			else
>@@ -3509,15 +3713,16 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
> 			psrch_inf->srch_entries_start = response_data;
> 			psrch_inf->ntwrk_buf_start = (char *)pSMB;
> 			psrch_inf->smallBuf = 0;
>-			if(parms->EndofSearch)
>+			if (parms->EndofSearch)
> 				psrch_inf->endOfSearch = TRUE;
> 			else
> 				psrch_inf->endOfSearch = FALSE;
>-                                                                                              
>-			psrch_inf->entries_in_buffer  = le16_to_cpu(parms->SearchCount);
>+			psrch_inf->entries_in_buffer =
>+						le16_to_cpu(parms->SearchCount);
> 			psrch_inf->index_of_last_entry +=
> 				psrch_inf->entries_in_buffer;
>-/*  cFYI(1,("fnxt2 entries in buf %d index_of_last %d",psrch_inf->entries_in_buffer,psrch_inf->index_of_last_entry)); */
>+/*  cFYI(1,("fnxt2 entries in buf %d index_of_last %d",
>+	    psrch_inf->entries_in_buffer, psrch_inf->index_of_last_entry)); */
> 
> 			/* BB fixme add unlock here */
> 		}
>@@ -3532,12 +3737,12 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
> FNext2_err_exit:
> 	if (rc != 0)
> 		cifs_buf_release(pSMB);
>-                                                                                              
> 	return rc;
> }
> 
> int
>-CIFSFindClose(const int xid, struct cifsTconInfo *tcon, const __u16 searchHandle)
>+CIFSFindClose(const int xid, struct cifsTconInfo *tcon,
>+	      const __u16 searchHandle)
> {
> 	int rc = 0;
> 	FINDCLOSE_REQ *pSMB = NULL;
>@@ -3549,7 +3754,7 @@ CIFSFindClose(const int xid, struct cifsTconInfo *tcon, const __u16 searchHandle
> 
> 	/* no sense returning error if session restarted
> 		as file handle has been closed */
>-	if(rc == -EAGAIN)
>+	if (rc == -EAGAIN)
> 		return 0;
> 	if (rc)
> 		return rc;
>@@ -3574,9 +3779,9 @@ CIFSFindClose(const int xid, struct cifsTconInfo *tcon, const __u16 searchHandle
> 
> int
> CIFSGetSrvInodeNumber(const int xid, struct cifsTconInfo *tcon,
>-                const unsigned char *searchName,
>-                __u64 * inode_number,
>-                const struct nls_table *nls_codepage, int remap)
>+		      const unsigned char *searchName,
>+		      __u64 * inode_number,
>+		      const struct nls_table *nls_codepage, int remap)
> {
> 	int rc = 0;
> 	TRANSACTION2_QPI_REQ *pSMB = NULL;
>@@ -3584,24 +3789,23 @@ CIFSGetSrvInodeNumber(const int xid, struct cifsTconInfo *tcon,
> 	int name_len, bytes_returned;
> 	__u16 params, byte_count;
> 
>-	cFYI(1,("In GetSrvInodeNum for %s",searchName));
>-	if(tcon == NULL)
>-		return -ENODEV; 
>+	cFYI(1, ("In GetSrvInodeNum for %s", searchName));
>+	if (tcon == NULL)
>+		return -ENODEV;
> 
> GetInodeNumberRetry:
> 	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
>-                      (void **) &pSMBr);
>+		      (void **) &pSMBr);
> 	if (rc)
> 		return rc;
> 
>-
> 	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
> 		name_len =
> 			cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
>-				PATH_MAX,nls_codepage, remap);
>+					 PATH_MAX, nls_codepage, remap);
> 		name_len++;     /* trailing null */
> 		name_len *= 2;
>-	} else {                /* BB improve the check for buffer overruns BB */
>+	} else {	/* BB improve the check for buffer overruns BB */
> 		name_len = strnlen(searchName, PATH_MAX);
> 		name_len++;     /* trailing null */
> 		strncpy(pSMB->FileName, searchName, name_len);
>@@ -3618,7 +3822,7 @@ GetInodeNumberRetry:
> 	pSMB->Timeout = 0;
> 	pSMB->Reserved2 = 0;
> 	pSMB->ParameterOffset = cpu_to_le16(offsetof(
>-		struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
>+		struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
> 	pSMB->DataCount = 0;
> 	pSMB->DataOffset = 0;
> 	pSMB->SetupCount = 1;
>@@ -3644,12 +3848,12 @@ GetInodeNumberRetry:
> 			/* If rc should we check for EOPNOSUPP and
> 			disable the srvino flag? or in caller? */
> 			rc = -EIO;      /* bad smb */
>-                else {
>+		else {
> 			__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
> 			__u16 count = le16_to_cpu(pSMBr->t2.DataCount);
>-			struct file_internal_info * pfinfo;
>+			struct file_internal_info *pfinfo;
> 			/* BB Do we need a cast or hash here ? */
>-			if(count < 8) {
>+			if (count < 8) {
> 				cFYI(1, ("Illegal size ret in QryIntrnlInf"));
> 				rc = -EIO;
> 				goto GetInodeNumOut;
>@@ -3676,12 +3880,12 @@ CIFSGetDFSRefer(const int xid, struct cifsSesInfo *ses,
> /* TRANS2_GET_DFS_REFERRAL */
> 	TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
> 	TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
>-	struct dfs_referral_level_3 * referrals = NULL;
>+	struct dfs_referral_level_3 *referrals = NULL;
> 	int rc = 0;
> 	int bytes_returned;
> 	int name_len;
> 	unsigned int i;
>-	char * temp;
>+	char *temp;
> 	__u16 params, byte_count;
> 	*number_of_UNC_in_array = 0;
> 	*targetUNCs = NULL;
>@@ -3694,18 +3898,16 @@ getDFSRetry:
> 		      (void **) &pSMBr);
> 	if (rc)
> 		return rc;
>-	
>-	/* server pointer checked in called function, 
>+
>+	/* server pointer checked in called function,
> 	but should never be null here anyway */
> 	pSMB->hdr.Mid = GetNextMid(ses->server);
> 	pSMB->hdr.Tid = ses->ipc_tid;
> 	pSMB->hdr.Uid = ses->Suid;
>-	if (ses->capabilities & CAP_STATUS32) {
>+	if (ses->capabilities & CAP_STATUS32)
> 		pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
>-	}
>-	if (ses->capabilities & CAP_DFS) {
>+	if (ses->capabilities & CAP_DFS)
> 		pSMB->hdr.Flags2 |= SMBFLG2_DFS;
>-	}
> 
> 	if (ses->capabilities & CAP_UNICODE) {
> 		pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
>@@ -3714,19 +3916,19 @@ getDFSRetry:
> 				     searchName, PATH_MAX, nls_codepage, remap);
> 		name_len++;	/* trailing null */
> 		name_len *= 2;
>-	} else {		/* BB improve the check for buffer overruns BB */
>+	} else {	/* BB improve the check for buffer overruns BB */
> 		name_len = strnlen(searchName, PATH_MAX);
> 		name_len++;	/* trailing null */
> 		strncpy(pSMB->RequestFileName, searchName, name_len);
> 	}
> 
>-	if(ses->server) {
>-		if(ses->server->secMode &
>+	if (ses->server) {
>+		if (ses->server->secMode &
> 		   (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
> 			pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
> 	}
> 
>-        pSMB->hdr.Uid = ses->Suid;
>+	pSMB->hdr.Uid = ses->Suid;
> 
> 	params = 2 /* level */  + name_len /*includes null */ ;
> 	pSMB->TotalDataCount = 0;
>@@ -3740,7 +3942,7 @@ getDFSRetry:
> 	pSMB->Timeout = 0;
> 	pSMB->Reserved2 = 0;
> 	pSMB->ParameterOffset = cpu_to_le16(offsetof(
>-        struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
>+	  struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
> 	pSMB->SetupCount = 1;
> 	pSMB->Reserved3 = 0;
> 	pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
>@@ -3759,74 +3961,87 @@ getDFSRetry:
> /* BB Add logic to parse referrals here */
> 		rc = validate_t2((struct smb_t2_rsp *)pSMBr);
> 
>-		if (rc || (pSMBr->ByteCount < 17))      /* BB also check enough total bytes returned */
>+		/* BB Also check if enough total bytes returned? */
>+		if (rc || (pSMBr->ByteCount < 17))
> 			rc = -EIO;      /* bad smb */
> 		else {
>-			__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 
>+			__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
> 			__u16 data_count = le16_to_cpu(pSMBr->t2.DataCount);
> 
> 			cFYI(1,
>-			     ("Decoding GetDFSRefer response.  BCC: %d  Offset %d",
>+			    ("Decoding GetDFSRefer response BCC: %d  Offset %d",
> 			      pSMBr->ByteCount, data_offset));
>-			referrals = 
>-			    (struct dfs_referral_level_3 *) 
>+			referrals =
>+			    (struct dfs_referral_level_3 *)
> 					(8 /* sizeof start of data block */ +
> 					data_offset +
>-					(char *) &pSMBr->hdr.Protocol); 
>-			cFYI(1,("num_referrals: %d dfs flags: 0x%x ... \nfor referral one refer size: 0x%x srv type: 0x%x refer flags: 0x%x ttl: 0x%x",
>-				le16_to_cpu(pSMBr->NumberOfReferrals),le16_to_cpu(pSMBr->DFSFlags), le16_to_cpu(referrals->ReferralSize),le16_to_cpu(referrals->ServerType),le16_to_cpu(referrals->ReferralFlags),le16_to_cpu(referrals->TimeToLive)));
>+					(char *) &pSMBr->hdr.Protocol);
>+			cFYI(1, ("num_referrals: %d dfs flags: 0x%x ... \n"
>+				"for referral one refer size: 0x%x srv "
>+				"type: 0x%x refer flags: 0x%x ttl: 0x%x",
>+				le16_to_cpu(pSMBr->NumberOfReferrals),
>+				le16_to_cpu(pSMBr->DFSFlags),
>+				le16_to_cpu(referrals->ReferralSize),
>+				le16_to_cpu(referrals->ServerType),
>+				le16_to_cpu(referrals->ReferralFlags),
>+				le16_to_cpu(referrals->TimeToLive)));
> 			/* BB This field is actually two bytes in from start of
> 			   data block so we could do safety check that DataBlock
> 			   begins at address of pSMBr->NumberOfReferrals */
>-			*number_of_UNC_in_array = le16_to_cpu(pSMBr->NumberOfReferrals);
>+			*number_of_UNC_in_array =
>+					le16_to_cpu(pSMBr->NumberOfReferrals);
> 
> 			/* BB Fix below so can return more than one referral */
>-			if(*number_of_UNC_in_array > 1)
>+			if (*number_of_UNC_in_array > 1)
> 				*number_of_UNC_in_array = 1;
> 
> 			/* get the length of the strings describing refs */
> 			name_len = 0;
>-			for(i=0;i<*number_of_UNC_in_array;i++) {
>+			for (i = 0; i < *number_of_UNC_in_array; i++) {
> 				/* make sure that DfsPathOffset not past end */
>-				__u16 offset = le16_to_cpu(referrals->DfsPathOffset);
>+				__u16 offset =
>+					le16_to_cpu(referrals->DfsPathOffset);
> 				if (offset > data_count) {
>-					/* if invalid referral, stop here and do 
>+					/* if invalid referral, stop here and do
> 					not try to copy any more */
> 					*number_of_UNC_in_array = i;
> 					break;
>-				} 
>+				}
> 				temp = ((char *)referrals) + offset;
> 
> 				if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
>-					name_len += UniStrnlen((wchar_t *)temp,data_count);
>+					name_len += UniStrnlen((wchar_t *)temp,
>+								data_count);
> 				} else {
>-					name_len += strnlen(temp,data_count);
>+					name_len += strnlen(temp, data_count);
> 				}
> 				referrals++;
>-				/* BB add check that referral pointer does not fall off end PDU */
>-				
>+				/* BB add check that referral pointer does
>+				   not fall off end PDU */
> 			}
> 			/* BB add check for name_len bigger than bcc */
>-			*targetUNCs = 
>-				kmalloc(name_len+1+ (*number_of_UNC_in_array),GFP_KERNEL);
>-			if(*targetUNCs == NULL) {
>+			*targetUNCs =
>+				kmalloc(name_len+1+(*number_of_UNC_in_array),
>+					GFP_KERNEL);
>+			if (*targetUNCs == NULL) {
> 				rc = -ENOMEM;
> 				goto GetDFSRefExit;
> 			}
> 			/* copy the ref strings */
>-			referrals =  
>-			    (struct dfs_referral_level_3 *) 
>-					(8 /* sizeof data hdr */ +
>-					data_offset + 
>+			referrals = (struct dfs_referral_level_3 *)
>+					(8 /* sizeof data hdr */ + data_offset +
> 					(char *) &pSMBr->hdr.Protocol);
> 
>-			for(i=0;i<*number_of_UNC_in_array;i++) {
>-				temp = ((char *)referrals) + le16_to_cpu(referrals->DfsPathOffset);
>+			for (i = 0; i < *number_of_UNC_in_array; i++) {
>+				temp = ((char *)referrals) +
>+					  le16_to_cpu(referrals->DfsPathOffset);
> 				if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
> 					cifs_strfromUCS_le(*targetUNCs,
>-						(__le16 *) temp, name_len, nls_codepage);
>+							  (__le16 *) temp,
>+							  name_len,
>+							  nls_codepage);
> 				} else {
>-					strncpy(*targetUNCs,temp,name_len);
>+					strncpy(*targetUNCs, temp, name_len);
> 				}
> 				/*  BB update target_uncs pointers */
> 				referrals++;
>@@ -3907,18 +4122,17 @@ oldQFSInfoRetry:
> 			rc = -EIO;      /* bad smb */
> 		else {
> 			__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
>-			cFYI(1,("qfsinf resp BCC: %d  Offset %d",
>+			cFYI(1, ("qfsinf resp BCC: %d  Offset %d",
> 				 pSMBr->ByteCount, data_offset));
> 
>-			response_data =
>-				(FILE_SYSTEM_ALLOC_INFO *) 
>+			response_data = (FILE_SYSTEM_ALLOC_INFO *)
> 				(((char *) &pSMBr->hdr.Protocol) + data_offset);
> 			FSData->f_bsize =
> 				le16_to_cpu(response_data->BytesPerSector) *
> 				le32_to_cpu(response_data->
> 					SectorsPerAllocationUnit);
> 			FSData->f_blocks =
>-				le32_to_cpu(response_data->TotalAllocationUnits);
>+			       le32_to_cpu(response_data->TotalAllocationUnits);
> 			FSData->f_bfree = FSData->f_bavail =
> 				le32_to_cpu(response_data->FreeAllocationUnits);
> 			cFYI(1,
>@@ -3971,7 +4185,7 @@ QFSInfoRetry:
> 	pSMB->TotalParameterCount = cpu_to_le16(params);
> 	pSMB->ParameterCount = pSMB->TotalParameterCount;
> 	pSMB->ParameterOffset = cpu_to_le16(offsetof(
>-        struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
>+		struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
> 	pSMB->DataCount = 0;
> 	pSMB->DataOffset = 0;
> 	pSMB->SetupCount = 1;
>@@ -3986,7 +4200,7 @@ QFSInfoRetry:
> 	if (rc) {
> 		cFYI(1, ("Send error in QFSInfo = %d", rc));
> 	} else {		/* decode response */
>-                rc = validate_t2((struct smb_t2_rsp *)pSMBr);
>+		rc = validate_t2((struct smb_t2_rsp *)pSMBr);
> 
> 		if (rc || (pSMBr->ByteCount < 24))
> 			rc = -EIO;	/* bad smb */
>@@ -4051,7 +4265,7 @@ QFSAttributeRetry:
> 	pSMB->TotalParameterCount = cpu_to_le16(params);
> 	pSMB->ParameterCount = pSMB->TotalParameterCount;
> 	pSMB->ParameterOffset = cpu_to_le16(offsetof(
>-        struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
>+		struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
> 	pSMB->DataCount = 0;
> 	pSMB->DataOffset = 0;
> 	pSMB->SetupCount = 1;
>@@ -4068,7 +4282,8 @@ QFSAttributeRetry:
> 	} else {		/* decode response */
> 		rc = validate_t2((struct smb_t2_rsp *)pSMBr);
> 
>-		if (rc || (pSMBr->ByteCount < 13)) {	/* BB also check enough bytes returned */
>+		if (rc || (pSMBr->ByteCount < 13)) {
>+			/* BB also check if enough bytes returned */
> 			rc = -EIO;	/* bad smb */
> 		} else {
> 			__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
>@@ -4077,7 +4292,7 @@ QFSAttributeRetry:
> 			     *) (((char *) &pSMBr->hdr.Protocol) +
> 				 data_offset);
> 			memcpy(&tcon->fsAttrInfo, response_data,
>-			       sizeof (FILE_SYSTEM_ATTRIBUTE_INFO));
>+			       sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
> 		}
> 	}
> 	cifs_buf_release(pSMB);
>@@ -4119,7 +4334,7 @@ QFSDeviceRetry:
> 	pSMB->TotalParameterCount = cpu_to_le16(params);
> 	pSMB->ParameterCount = pSMB->TotalParameterCount;
> 	pSMB->ParameterOffset = cpu_to_le16(offsetof(
>-        struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
>+		struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
> 
> 	pSMB->DataCount = 0;
> 	pSMB->DataOffset = 0;
>@@ -4146,7 +4361,7 @@ QFSDeviceRetry:
> 				(((char *) &pSMBr->hdr.Protocol) +
> 				 data_offset);
> 			memcpy(&tcon->fsDevInfo, response_data,
>-			       sizeof (FILE_SYSTEM_DEVICE_INFO));
>+			       sizeof(FILE_SYSTEM_DEVICE_INFO));
> 		}
> 	}
> 	cifs_buf_release(pSMB);
>@@ -4189,8 +4404,8 @@ QFSUnixRetry:
> 	byte_count = params + 1 /* pad */ ;
> 	pSMB->ParameterCount = cpu_to_le16(params);
> 	pSMB->TotalParameterCount = pSMB->ParameterCount;
>-	pSMB->ParameterOffset = cpu_to_le16(offsetof(struct 
>-        smb_com_transaction2_qfsi_req, InformationLevel) - 4);
>+	pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
>+			smb_com_transaction2_qfsi_req, InformationLevel) - 4);
> 	pSMB->SetupCount = 1;
> 	pSMB->Reserved3 = 0;
> 	pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
>@@ -4214,7 +4429,7 @@ QFSUnixRetry:
> 			     *) (((char *) &pSMBr->hdr.Protocol) +
> 				 data_offset);
> 			memcpy(&tcon->fsUnixInfo, response_data,
>-			       sizeof (FILE_SYSTEM_UNIX_INFO));
>+			       sizeof(FILE_SYSTEM_UNIX_INFO));
> 		}
> 	}
> 	cifs_buf_release(pSMB);
>@@ -4250,7 +4465,8 @@ SETFSUnixRetry:
> 	pSMB->Flags = 0;
> 	pSMB->Timeout = 0;
> 	pSMB->Reserved2 = 0;
>-	param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum) - 4;
>+	param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum)
>+				- 4;
> 	offset = param_offset + params;
> 
> 	pSMB->MaxParameterCount = cpu_to_le16(4);
>@@ -4336,8 +4552,8 @@ QFSPosixRetry:
> 	byte_count = params + 1 /* pad */ ;
> 	pSMB->ParameterCount = cpu_to_le16(params);
> 	pSMB->TotalParameterCount = pSMB->ParameterCount;
>-	pSMB->ParameterOffset = cpu_to_le16(offsetof(struct 
>-        smb_com_transaction2_qfsi_req, InformationLevel) - 4);
>+	pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
>+			smb_com_transaction2_qfsi_req, InformationLevel) - 4);
> 	pSMB->SetupCount = 1;
> 	pSMB->Reserved3 = 0;
> 	pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
>@@ -4366,18 +4582,18 @@ QFSPosixRetry:
> 					le64_to_cpu(response_data->TotalBlocks);
> 			FSData->f_bfree =
> 			    le64_to_cpu(response_data->BlocksAvail);
>-			if(response_data->UserBlocksAvail == cpu_to_le64(-1)) {
>+			if (response_data->UserBlocksAvail == cpu_to_le64(-1)) {
> 				FSData->f_bavail = FSData->f_bfree;
> 			} else {
> 				FSData->f_bavail =
>-					le64_to_cpu(response_data->UserBlocksAvail);
>+				    le64_to_cpu(response_data->UserBlocksAvail);
> 			}
>-			if(response_data->TotalFileNodes != cpu_to_le64(-1))
>+			if (response_data->TotalFileNodes != cpu_to_le64(-1))
> 				FSData->f_files =
>-					le64_to_cpu(response_data->TotalFileNodes);
>-			if(response_data->FreeFileNodes != cpu_to_le64(-1))
>+				     le64_to_cpu(response_data->TotalFileNodes);
>+			if (response_data->FreeFileNodes != cpu_to_le64(-1))
> 				FSData->f_ffree =
>-					le64_to_cpu(response_data->FreeFileNodes);
>+				      le64_to_cpu(response_data->FreeFileNodes);
> 		}
> 	}
> 	cifs_buf_release(pSMB);
>@@ -4389,15 +4605,15 @@ QFSPosixRetry:
> }
> 
> 
>-/* We can not use write of zero bytes trick to 
>-   set file size due to need for large file support.  Also note that 
>-   this SetPathInfo is preferred to SetFileInfo based method in next 
>+/* We can not use write of zero bytes trick to
>+   set file size due to need for large file support.  Also note that
>+   this SetPathInfo is preferred to SetFileInfo based method in next
>    routine which is only needed to work around a sharing violation bug
>    in Samba which this routine can run into */
> 
> int
> CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon, const char *fileName,
>-	      __u64 size, int SetAllocation, 
>+	      __u64 size, int SetAllocation,
> 	      const struct nls_table *nls_codepage, int remap)
> {
> 	struct smb_com_transaction2_spi_req *pSMB = NULL;
>@@ -4427,7 +4643,7 @@ SetEOFRetry:
> 		strncpy(pSMB->FileName, fileName, name_len);
> 	}
> 	params = 6 + name_len;
>-	data_count = sizeof (struct file_end_of_file_info);
>+	data_count = sizeof(struct file_end_of_file_info);
> 	pSMB->MaxParameterCount = cpu_to_le16(2);
> 	pSMB->MaxDataCount = cpu_to_le16(4100);
> 	pSMB->MaxSetupCount = 0;
>@@ -4436,22 +4652,22 @@ SetEOFRetry:
> 	pSMB->Timeout = 0;
> 	pSMB->Reserved2 = 0;
> 	param_offset = offsetof(struct smb_com_transaction2_spi_req,
>-                                     InformationLevel) - 4;
>+				InformationLevel) - 4;
> 	offset = param_offset + params;
>-	if(SetAllocation) {
>-        	if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
>-	            pSMB->InformationLevel =
>-                	cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
>-        	else
>-	            pSMB->InformationLevel =
>-        	        cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
>-	} else /* Set File Size */  {    
>+	if (SetAllocation) {
>+		if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
>+			pSMB->InformationLevel =
>+				cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
>+		else
>+			pSMB->InformationLevel =
>+				cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
>+	} else /* Set File Size */  {
> 	    if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
> 		    pSMB->InformationLevel =
>-		        cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
>+				cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
> 	    else
> 		    pSMB->InformationLevel =
>-		        cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
>+				cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
> 	}
> 
> 	parm_data =
>@@ -4486,8 +4702,8 @@ SetEOFRetry:
> }
> 
> int
>-CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size, 
>-                   __u16 fid, __u32 pid_of_opener, int SetAllocation)
>+CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
>+		   __u16 fid, __u32 pid_of_opener, int SetAllocation)
> {
> 	struct smb_com_transaction2_sfi_req *pSMB  = NULL;
> 	struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
>@@ -4508,7 +4724,7 @@ CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
> 
> 	pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
> 	pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
>-    
>+
> 	params = 6;
> 	pSMB->MaxSetupCount = 0;
> 	pSMB->Reserved = 0;
>@@ -4518,7 +4734,7 @@ CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
> 	param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
> 	offset = param_offset + params;
> 
>-	data_offset = (char *) (&pSMB->hdr.Protocol) + offset;	
>+	data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
> 
> 	count = sizeof(struct file_end_of_file_info);
> 	pSMB->MaxParameterCount = cpu_to_le16(2);
>@@ -4533,25 +4749,25 @@ CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
> 	pSMB->TotalParameterCount = pSMB->ParameterCount;
> 	pSMB->ParameterOffset = cpu_to_le16(param_offset);
> 	parm_data =
>-		(struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
>-			offset);
>+		(struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol)
>+				+ offset);
> 	pSMB->DataOffset = cpu_to_le16(offset);
> 	parm_data->FileSize = cpu_to_le64(size);
> 	pSMB->Fid = fid;
>-	if(SetAllocation) {
>+	if (SetAllocation) {
> 		if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
> 			pSMB->InformationLevel =
> 				cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
> 		else
> 			pSMB->InformationLevel =
> 				cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
>-	} else /* Set File Size */  {    
>+	} else /* Set File Size */  {
> 	    if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
> 		    pSMB->InformationLevel =
>-		        cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
>+				cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
> 	    else
> 		    pSMB->InformationLevel =
>-		        cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
>+				cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
> 	}
> 	pSMB->Reserved4 = 0;
> 	pSMB->hdr.smb_buf_length += byte_count;
>@@ -4567,21 +4783,21 @@ CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
> 	if (pSMB)
> 		cifs_small_buf_release(pSMB);
> 
>-	/* Note: On -EAGAIN error only caller can retry on handle based calls 
>+	/* Note: On -EAGAIN error only caller can retry on handle based calls
> 		since file handle passed in no longer valid */
> 
> 	return rc;
> }
> 
>-/* Some legacy servers such as NT4 require that the file times be set on 
>+/* Some legacy servers such as NT4 require that the file times be set on
>    an open handle, rather than by pathname - this is awkward due to
>    potential access conflicts on the open, but it is unavoidable for these
>    old servers since the only other choice is to go from 100 nanosecond DCE
>    time and resort to the original setpathinfo level which takes the ancient
>    DOS time format with 2 second granularity */
> int
>-CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon, const FILE_BASIC_INFO * data, 
>-                   __u16 fid)
>+CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon,
>+		    const FILE_BASIC_INFO *data, __u16 fid)
> {
> 	struct smb_com_transaction2_sfi_req *pSMB  = NULL;
> 	struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
>@@ -4603,7 +4819,7 @@ CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon, const FILE_BASIC_I
> 	use an existing handle (rather than opening one on the fly) */
> 	/* pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
> 	pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));*/
>-    
>+
> 	params = 6;
> 	pSMB->MaxSetupCount = 0;
> 	pSMB->Reserved = 0;
>@@ -4613,9 +4829,9 @@ CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon, const FILE_BASIC_I
> 	param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
> 	offset = param_offset + params;
> 
>-	data_offset = (char *) (&pSMB->hdr.Protocol) + offset; 
>+	data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
> 
>-	count = sizeof (FILE_BASIC_INFO);
>+	count = sizeof(FILE_BASIC_INFO);
> 	pSMB->MaxParameterCount = cpu_to_le16(2);
> 	pSMB->MaxDataCount = cpu_to_le16(1000);	/* BB find max SMB PDU from sess */
> 	pSMB->SetupCount = 1;
>@@ -4636,16 +4852,16 @@ CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon, const FILE_BASIC_I
> 	pSMB->Reserved4 = 0;
> 	pSMB->hdr.smb_buf_length += byte_count;
> 	pSMB->ByteCount = cpu_to_le16(byte_count);
>-	memcpy(data_offset,data,sizeof(FILE_BASIC_INFO));
>+	memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
> 	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
> 			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
> 	if (rc) {
>-		cFYI(1,("Send error in Set Time (SetFileInfo) = %d",rc));
>+		cFYI(1, ("Send error in Set Time (SetFileInfo) = %d", rc));
> 	}
> 
> 	cifs_small_buf_release(pSMB);
> 
>-	/* Note: On -EAGAIN error only caller can retry on handle based calls 
>+	/* Note: On -EAGAIN error only caller can retry on handle based calls
> 		since file handle passed in no longer valid */
> 
> 	return rc;
>@@ -4654,7 +4870,7 @@ CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon, const FILE_BASIC_I
> 
> int
> CIFSSMBSetTimes(const int xid, struct cifsTconInfo *tcon, const char *fileName,
>-		const FILE_BASIC_INFO * data, 
>+		const FILE_BASIC_INFO *data,
> 		const struct nls_table *nls_codepage, int remap)
> {
> 	TRANSACTION2_SPI_REQ *pSMB = NULL;
>@@ -4679,14 +4895,14 @@ SetTimesRetry:
> 				     PATH_MAX, nls_codepage, remap);
> 		name_len++;	/* trailing null */
> 		name_len *= 2;
>-	} else {		/* BB improve the check for buffer overruns BB */
>+	} else {	/* BB improve the check for buffer overruns BB */
> 		name_len = strnlen(fileName, PATH_MAX);
> 		name_len++;	/* trailing null */
> 		strncpy(pSMB->FileName, fileName, name_len);
> 	}
> 
> 	params = 6 + name_len;
>-	count = sizeof (FILE_BASIC_INFO);
>+	count = sizeof(FILE_BASIC_INFO);
> 	pSMB->MaxParameterCount = cpu_to_le16(2);
> 	pSMB->MaxDataCount = cpu_to_le16(1000);	/* BB find exact max SMB PDU from sess structure BB */
> 	pSMB->MaxSetupCount = 0;
>@@ -4695,7 +4911,7 @@ SetTimesRetry:
> 	pSMB->Timeout = 0;
> 	pSMB->Reserved2 = 0;
> 	param_offset = offsetof(struct smb_com_transaction2_spi_req,
>-                                     InformationLevel) - 4;
>+				InformationLevel) - 4;
> 	offset = param_offset + params;
> 	data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
> 	pSMB->ParameterOffset = cpu_to_le16(param_offset);
>@@ -4715,7 +4931,7 @@ SetTimesRetry:
> 		pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
> 	pSMB->Reserved4 = 0;
> 	pSMB->hdr.smb_buf_length += byte_count;
>-	memcpy(data_offset, data, sizeof (FILE_BASIC_INFO));
>+	memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
> 	pSMB->ByteCount = cpu_to_le16(byte_count);
> 	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
> 			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
>@@ -4756,11 +4972,11 @@ SetAttrLgcyRetry:
> 
> 	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
> 		name_len =
>-			ConvertToUCS((__le16 *) pSMB->fileName, fileName, 
>+			ConvertToUCS((__le16 *) pSMB->fileName, fileName,
> 				PATH_MAX, nls_codepage);
> 		name_len++;     /* trailing null */
> 		name_len *= 2;
>-	} else {                /* BB improve the check for buffer overruns BB */
>+	} else {	/* BB improve the check for buffer overruns BB */
> 		name_len = strnlen(fileName, PATH_MAX);
> 		name_len++;     /* trailing null */
> 		strncpy(pSMB->fileName, fileName, name_len);
>@@ -4786,8 +5002,8 @@ SetAttrLgcyRetry:
> 
> int
> CIFSSMBUnixSetPerms(const int xid, struct cifsTconInfo *tcon,
>-		    char *fileName, __u64 mode, __u64 uid, __u64 gid, 
>-		    dev_t device, const struct nls_table *nls_codepage, 
>+		    char *fileName, __u64 mode, __u64 uid, __u64 gid,
>+		    dev_t device, const struct nls_table *nls_codepage,
> 		    int remap)
> {
> 	TRANSACTION2_SPI_REQ *pSMB = NULL;
>@@ -4807,7 +5023,7 @@ setPermsRetry:
> 
> 	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
> 		name_len =
>-		    cifsConvertToUCS((__le16 *) pSMB->FileName, fileName, 
>+		    cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
> 				     PATH_MAX, nls_codepage, remap);
> 		name_len++;	/* trailing null */
> 		name_len *= 2;
>@@ -4818,7 +5034,7 @@ setPermsRetry:
> 	}
> 
> 	params = 6 + name_len;
>-	count = sizeof (FILE_UNIX_BASIC_INFO);
>+	count = sizeof(FILE_UNIX_BASIC_INFO);
> 	pSMB->MaxParameterCount = cpu_to_le16(2);
> 	pSMB->MaxDataCount = cpu_to_le16(1000);	/* BB find exact max SMB PDU from sess structure BB */
> 	pSMB->MaxSetupCount = 0;
>@@ -4827,7 +5043,7 @@ setPermsRetry:
> 	pSMB->Timeout = 0;
> 	pSMB->Reserved2 = 0;
> 	param_offset = offsetof(struct smb_com_transaction2_spi_req,
>-                                     InformationLevel) - 4;
>+				InformationLevel) - 4;
> 	offset = param_offset + params;
> 	data_offset =
> 	    (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
>@@ -4850,7 +5066,7 @@ setPermsRetry:
> 	older clients, but we should be precise - we use SetFileSize to
> 	set file size and do not want to truncate file size to zero
> 	accidently as happened on one Samba server beta by putting
>-	zero instead of -1 here */ 
>+	zero instead of -1 here */
> 	data_offset->EndOfFile = NO_CHANGE_64;
> 	data_offset->NumOfBytes = NO_CHANGE_64;
> 	data_offset->LastStatusChange = NO_CHANGE_64;
>@@ -4862,20 +5078,20 @@ setPermsRetry:
> 	data_offset->DevMajor = cpu_to_le64(MAJOR(device));
> 	data_offset->DevMinor = cpu_to_le64(MINOR(device));
> 	data_offset->Permissions = cpu_to_le64(mode);
>-    
>-	if(S_ISREG(mode))
>+
>+	if (S_ISREG(mode))
> 		data_offset->Type = cpu_to_le32(UNIX_FILE);
>-	else if(S_ISDIR(mode))
>+	else if (S_ISDIR(mode))
> 		data_offset->Type = cpu_to_le32(UNIX_DIR);
>-	else if(S_ISLNK(mode))
>+	else if (S_ISLNK(mode))
> 		data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
>-	else if(S_ISCHR(mode))
>+	else if (S_ISCHR(mode))
> 		data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
>-	else if(S_ISBLK(mode))
>+	else if (S_ISBLK(mode))
> 		data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
>-	else if(S_ISFIFO(mode))
>+	else if (S_ISFIFO(mode))
> 		data_offset->Type = cpu_to_le32(UNIX_FIFO);
>-	else if(S_ISSOCK(mode))
>+	else if (S_ISSOCK(mode))
> 		data_offset->Type = cpu_to_le32(UNIX_SOCKET);
> 
> 
>@@ -4893,20 +5109,20 @@ setPermsRetry:
> 	return rc;
> }
> 
>-int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon, 
>+int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon,
> 		  const int notify_subdirs, const __u16 netfid,
>-		  __u32 filter, struct file * pfile, int multishot, 
>+		  __u32 filter, struct file *pfile, int multishot,
> 		  const struct nls_table *nls_codepage)
> {
> 	int rc = 0;
>-	struct smb_com_transaction_change_notify_req * pSMB = NULL;
>-	struct smb_com_ntransaction_change_notify_rsp * pSMBr = NULL;
>+	struct smb_com_transaction_change_notify_req *pSMB = NULL;
>+	struct smb_com_ntransaction_change_notify_rsp *pSMBr = NULL;
> 	struct dir_notify_req *dnotify_req;
> 	int bytes_returned;
> 
>-	cFYI(1, ("In CIFSSMBNotify for file handle %d",(int)netfid));
>+	cFYI(1, ("In CIFSSMBNotify for file handle %d", (int)netfid));
> 	rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
>-                      (void **) &pSMBr);
>+		      (void **) &pSMBr);
> 	if (rc)
> 		return rc;
> 
>@@ -4927,7 +5143,7 @@ int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon,
> 	pSMB->SetupCount = 4; /* single byte does not need le conversion */
> 	pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
> 	pSMB->ParameterCount = pSMB->TotalParameterCount;
>-	if(notify_subdirs)
>+	if (notify_subdirs)
> 		pSMB->WatchTree = 1; /* one byte - no le conversion needed */
> 	pSMB->Reserved2 = 0;
> 	pSMB->CompletionFilter = cpu_to_le32(filter);
>@@ -4940,11 +5156,11 @@ int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon,
> 		cFYI(1, ("Error in Notify = %d", rc));
> 	} else {
> 		/* Add file to outstanding requests */
>-		/* BB change to kmem cache alloc */	
>+		/* BB change to kmem cache alloc */
> 		dnotify_req = kmalloc(
> 						sizeof(struct dir_notify_req),
> 						 GFP_KERNEL);
>-		if(dnotify_req) {
>+		if (dnotify_req) {
> 			dnotify_req->Pid = pSMB->hdr.Pid;
> 			dnotify_req->PidHigh = pSMB->hdr.PidHigh;
> 			dnotify_req->Mid = pSMB->hdr.Mid;
>@@ -4955,20 +5171,20 @@ int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon,
> 			dnotify_req->filter = filter;
> 			dnotify_req->multishot = multishot;
> 			spin_lock(&GlobalMid_Lock);
>-			list_add_tail(&dnotify_req->lhead, 
>+			list_add_tail(&dnotify_req->lhead,
> 					&GlobalDnotifyReqList);
> 			spin_unlock(&GlobalMid_Lock);
>-		} else 
>+		} else
> 			rc = -ENOMEM;
> 	}
> 	cifs_buf_release(pSMB);
>-	return rc;	
>+	return rc;
> }
> #ifdef CONFIG_CIFS_XATTR
> ssize_t
> CIFSSMBQAllEAs(const int xid, struct cifsTconInfo *tcon,
> 		 const unsigned char *searchName,
>-		 char * EAData, size_t buf_size,
>+		 char *EAData, size_t buf_size,
> 		 const struct nls_table *nls_codepage, int remap)
> {
> 		/* BB assumes one setup word */
>@@ -4977,8 +5193,8 @@ CIFSSMBQAllEAs(const int xid, struct cifsTconInfo *tcon,
> 	int rc = 0;
> 	int bytes_returned;
> 	int name_len;
>-	struct fea * temp_fea;
>-	char * temp_ptr;
>+	struct fea *temp_fea;
>+	char *temp_ptr;
> 	__u16 params, byte_count;
> 
> 	cFYI(1, ("In Query All EAs path %s", searchName));
>@@ -4990,7 +5206,7 @@ QAllEAsRetry:
> 
> 	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
> 		name_len =
>-		    cifsConvertToUCS((__le16 *) pSMB->FileName, searchName, 
>+		    cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
> 				     PATH_MAX, nls_codepage, remap);
> 		name_len++;	/* trailing null */
> 		name_len *= 2;
>@@ -5000,7 +5216,7 @@ QAllEAsRetry:
> 		strncpy(pSMB->FileName, searchName, name_len);
> 	}
> 
>-	params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
>+	params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
> 	pSMB->TotalDataCount = 0;
> 	pSMB->MaxParameterCount = cpu_to_le16(2);
> 	pSMB->MaxDataCount = cpu_to_le16(4000);	/* BB find exact max SMB PDU from sess structure BB */
>@@ -5010,7 +5226,7 @@ QAllEAsRetry:
> 	pSMB->Timeout = 0;
> 	pSMB->Reserved2 = 0;
> 	pSMB->ParameterOffset = cpu_to_le16(offsetof(
>-        struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
>+	struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
> 	pSMB->DataCount = 0;
> 	pSMB->DataOffset = 0;
> 	pSMB->SetupCount = 1;
>@@ -5034,7 +5250,7 @@ QAllEAsRetry:
> 		/* BB also check enough total bytes returned */
> 		/* BB we need to improve the validity checking
> 		of these trans2 responses */
>-		if (rc || (pSMBr->ByteCount < 4)) 
>+		if (rc || (pSMBr->ByteCount < 4))
> 			rc = -EIO;	/* bad smb */
> 	   /* else if (pFindData){
> 			memcpy((char *) pFindData,
>@@ -5047,39 +5263,40 @@ QAllEAsRetry:
> 			/* check that each element of each entry does not
> 			   go beyond end of list */
> 			__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
>-			struct fealist * ea_response_data;
>+			struct fealist *ea_response_data;
> 			rc = 0;
> 			/* validate_trans2_offsets() */
>-			/* BB to check if(start of smb + data_offset > &bcc+ bcc)*/
>+			/* BB check if start of smb + data_offset > &bcc+ bcc */
> 			ea_response_data = (struct fealist *)
> 				(((char *) &pSMBr->hdr.Protocol) +
> 				data_offset);
> 			name_len = le32_to_cpu(ea_response_data->list_len);
>-			cFYI(1,("ea length %d", name_len));
>-			if(name_len <= 8) {
>+			cFYI(1, ("ea length %d", name_len));
>+			if (name_len <= 8) {
> 			/* returned EA size zeroed at top of function */
>-				cFYI(1,("empty EA list returned from server"));
>+				cFYI(1, ("empty EA list returned from server"));
> 			} else {
> 				/* account for ea list len */
> 				name_len -= 4;
> 				temp_fea = ea_response_data->list;
> 				temp_ptr = (char *)temp_fea;
>-				while(name_len > 0) {
>+				while (name_len > 0) {
> 					__u16 value_len;
> 					name_len -= 4;
> 					temp_ptr += 4;
> 					rc += temp_fea->name_len;
> 				/* account for prefix user. and trailing null */
>-					rc = rc + 5 + 1; 
>-					if(rc<(int)buf_size) {
>-						memcpy(EAData,"user.",5);
>-						EAData+=5;
>-						memcpy(EAData,temp_ptr,temp_fea->name_len);
>-						EAData+=temp_fea->name_len;
>+					rc = rc + 5 + 1;
>+					if (rc < (int)buf_size) {
>+						memcpy(EAData, "user.", 5);
>+						EAData += 5;
>+						memcpy(EAData, temp_ptr,
>+						       temp_fea->name_len);
>+						EAData += temp_fea->name_len;
> 						/* null terminate name */
> 						*EAData = 0;
> 						EAData = EAData + 1;
>-					} else if(buf_size == 0) {
>+					} else if (buf_size == 0) {
> 						/* skip copy - calc size only */
> 					} else {
> 						/* stop before overrun buffer */
>@@ -5091,11 +5308,15 @@ QAllEAsRetry:
> 					/* account for trailing null */
> 					name_len--;
> 					temp_ptr++;
>-					value_len = le16_to_cpu(temp_fea->value_len);
>+					value_len =
>+					      le16_to_cpu(temp_fea->value_len);
> 					name_len -= value_len;
> 					temp_ptr += value_len;
>-					/* BB check that temp_ptr is still within smb BB*/
>-				/* no trailing null to account for in value len */
>+					/* BB check that temp_ptr is still
>+					      within the SMB BB*/
>+
>+					/* no trailing null to account for
>+					   in value len */
> 					/* go on to next EA */
> 					temp_fea = (struct fea *)temp_ptr;
> 				}
>@@ -5110,9 +5331,9 @@ QAllEAsRetry:
> 	return (ssize_t)rc;
> }
> 
>-ssize_t CIFSSMBQueryEA(const int xid,struct cifsTconInfo * tcon,
>-		const unsigned char * searchName,const unsigned char * ea_name,
>-		unsigned char * ea_value, size_t buf_size, 
>+ssize_t CIFSSMBQueryEA(const int xid, struct cifsTconInfo *tcon,
>+		const unsigned char *searchName, const unsigned char *ea_name,
>+		unsigned char *ea_value, size_t buf_size,
> 		const struct nls_table *nls_codepage, int remap)
> {
> 	TRANSACTION2_QPI_REQ *pSMB = NULL;
>@@ -5120,8 +5341,8 @@ ssize_t CIFSSMBQueryEA(const int xid,struct cifsTconInfo * tcon,
> 	int rc = 0;
> 	int bytes_returned;
> 	int name_len;
>-	struct fea * temp_fea;
>-	char * temp_ptr;
>+	struct fea *temp_fea;
>+	char *temp_ptr;
> 	__u16 params, byte_count;
> 
> 	cFYI(1, ("In Query EA path %s", searchName));
>@@ -5133,7 +5354,7 @@ QEARetry:
> 
> 	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
> 		name_len =
>-		    cifsConvertToUCS((__le16 *) pSMB->FileName, searchName, 
>+		    cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
> 				     PATH_MAX, nls_codepage, remap);
> 		name_len++;	/* trailing null */
> 		name_len *= 2;
>@@ -5143,7 +5364,7 @@ QEARetry:
> 		strncpy(pSMB->FileName, searchName, name_len);
> 	}
> 
>-	params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
>+	params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
> 	pSMB->TotalDataCount = 0;
> 	pSMB->MaxParameterCount = cpu_to_le16(2);
> 	pSMB->MaxDataCount = cpu_to_le16(4000);	/* BB find exact max SMB PDU from sess structure BB */
>@@ -5153,7 +5374,7 @@ QEARetry:
> 	pSMB->Timeout = 0;
> 	pSMB->Reserved2 = 0;
> 	pSMB->ParameterOffset = cpu_to_le16(offsetof(
>-        struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
>+		struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
> 	pSMB->DataCount = 0;
> 	pSMB->DataOffset = 0;
> 	pSMB->SetupCount = 1;
>@@ -5177,7 +5398,7 @@ QEARetry:
> 		/* BB also check enough total bytes returned */
> 		/* BB we need to improve the validity checking
> 		of these trans2 responses */
>-		if (rc || (pSMBr->ByteCount < 4)) 
>+		if (rc || (pSMBr->ByteCount < 4))
> 			rc = -EIO;	/* bad smb */
> 	   /* else if (pFindData){
> 			memcpy((char *) pFindData,
>@@ -5190,18 +5411,18 @@ QEARetry:
> 			/* check that each element of each entry does not
> 			   go beyond end of list */
> 			__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
>-			struct fealist * ea_response_data;
>+			struct fealist *ea_response_data;
> 			rc = -ENODATA;
> 			/* validate_trans2_offsets() */
>-			/* BB to check if(start of smb + data_offset > &bcc+ bcc)*/
>+			/* BB check if start of smb + data_offset > &bcc+ bcc*/
> 			ea_response_data = (struct fealist *)
> 				(((char *) &pSMBr->hdr.Protocol) +
> 				data_offset);
> 			name_len = le32_to_cpu(ea_response_data->list_len);
>-			cFYI(1,("ea length %d", name_len));
>-			if(name_len <= 8) {
>+			cFYI(1, ("ea length %d", name_len));
>+			if (name_len <= 8) {
> 			/* returned EA size zeroed at top of function */
>-				cFYI(1,("empty EA list returned from server"));
>+				cFYI(1, ("empty EA list returned from server"));
> 			} else {
> 				/* account for ea list len */
> 				name_len -= 4;
>@@ -5209,28 +5430,30 @@ QEARetry:
> 				temp_ptr = (char *)temp_fea;
> 				/* loop through checking if we have a matching
> 				name and then return the associated value */
>-				while(name_len > 0) {
>+				while (name_len > 0) {
> 					__u16 value_len;
> 					name_len -= 4;
> 					temp_ptr += 4;
>-					value_len = le16_to_cpu(temp_fea->value_len);
>-				/* BB validate that value_len falls within SMB, 
>-				even though maximum for name_len is 255 */ 
>-					if(memcmp(temp_fea->name,ea_name,
>+					value_len =
>+					      le16_to_cpu(temp_fea->value_len);
>+				/* BB validate that value_len falls within SMB,
>+				even though maximum for name_len is 255 */
>+					if (memcmp(temp_fea->name, ea_name,
> 						  temp_fea->name_len) == 0) {
> 						/* found a match */
> 						rc = value_len;
> 				/* account for prefix user. and trailing null */
>-						if(rc<=(int)buf_size) {
>+						if (rc <= (int)buf_size) {
> 							memcpy(ea_value,
> 								temp_fea->name+temp_fea->name_len+1,
> 								rc);
>-							/* ea values, unlike ea names,
>-							are not null terminated */
>-						} else if(buf_size == 0) {
>+							/* ea values, unlike ea
>+							   names, are not null
>+							   terminated */
>+						} else if (buf_size == 0) {
> 						/* skip copy - calc size only */
> 						} else {
>-							/* stop before overrun buffer */
>+						/* stop before overrun buffer */
> 							rc = -ERANGE;
> 						}
> 						break;
>@@ -5242,11 +5465,11 @@ QEARetry:
> 					temp_ptr++;
> 					name_len -= value_len;
> 					temp_ptr += value_len;
>-				/* no trailing null to account for in value len */
>-					/* go on to next EA */
>+					/* No trailing null to account for in
>+					   value_len.  Go on to next EA */
> 					temp_fea = (struct fea *)temp_ptr;
> 				}
>-			} 
>+			}
> 		}
> 	}
> 	if (pSMB)
>@@ -5259,9 +5482,9 @@ QEARetry:
> 
> int
> CIFSSMBSetEA(const int xid, struct cifsTconInfo *tcon, const char *fileName,
>-		const char * ea_name, const void * ea_value, 
>-		const __u16 ea_value_len, const struct nls_table *nls_codepage,
>-		int remap)
>+	     const char *ea_name, const void *ea_value,
>+	     const __u16 ea_value_len, const struct nls_table *nls_codepage,
>+	     int remap)
> {
> 	struct smb_com_transaction2_spi_req *pSMB = NULL;
> 	struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
>@@ -5280,11 +5503,11 @@ SetEARetry:
> 
> 	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
> 		name_len =
>-		    cifsConvertToUCS((__le16 *) pSMB->FileName, fileName, 
>+		    cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
> 				     PATH_MAX, nls_codepage, remap);
> 		name_len++;	/* trailing null */
> 		name_len *= 2;
>-	} else {		/* BB improve the check for buffer overruns BB */
>+	} else {	/* BB improve the check for buffer overruns BB */
> 		name_len = strnlen(fileName, PATH_MAX);
> 		name_len++;	/* trailing null */
> 		strncpy(pSMB->FileName, fileName, name_len);
>@@ -5295,10 +5518,10 @@ SetEARetry:
> 	/* done calculating parms using name_len of file name,
> 	now use name_len to calculate length of ea name
> 	we are going to create in the inode xattrs */
>-	if(ea_name == NULL)
>+	if (ea_name == NULL)
> 		name_len = 0;
> 	else
>-		name_len = strnlen(ea_name,255);
>+		name_len = strnlen(ea_name, 255);
> 
> 	count = sizeof(*parm_data) + ea_value_len + name_len + 1;
> 	pSMB->MaxParameterCount = cpu_to_le16(2);
>@@ -5309,7 +5532,7 @@ SetEARetry:
> 	pSMB->Timeout = 0;
> 	pSMB->Reserved2 = 0;
> 	param_offset = offsetof(struct smb_com_transaction2_spi_req,
>-                                     InformationLevel) - 4;
>+				InformationLevel) - 4;
> 	offset = param_offset + params;
> 	pSMB->InformationLevel =
> 		cpu_to_le16(SMB_SET_FILE_EA);
>@@ -5327,19 +5550,21 @@ SetEARetry:
> 	parm_data->list_len = cpu_to_le32(count);
> 	parm_data->list[0].EA_flags = 0;
> 	/* we checked above that name len is less than 255 */
>-	parm_data->list[0].name_len = (__u8)name_len;;
>+	parm_data->list[0].name_len = (__u8)name_len;
> 	/* EA names are always ASCII */
>-	if(ea_name)
>-		strncpy(parm_data->list[0].name,ea_name,name_len);
>+	if (ea_name)
>+		strncpy(parm_data->list[0].name, ea_name, name_len);
> 	parm_data->list[0].name[name_len] = 0;
> 	parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
> 	/* caller ensures that ea_value_len is less than 64K but
> 	we need to ensure that it fits within the smb */
> 
>-	/*BB add length check that it would fit in negotiated SMB buffer size BB */
>-	/* if(ea_value_len > buffer_size - 512 (enough for header)) */
>-	if(ea_value_len)
>-		memcpy(parm_data->list[0].name+name_len+1,ea_value,ea_value_len);
>+	/*BB add length check to see if it would fit in
>+	     negotiated SMB buffer size BB */
>+	/* if (ea_value_len > buffer_size - 512 (enough for header)) */
>+	if (ea_value_len)
>+		memcpy(parm_data->list[0].name+name_len+1,
>+		       ea_value, ea_value_len);
> 
> 	pSMB->TotalDataCount = pSMB->DataCount;
> 	pSMB->ParameterCount = cpu_to_le16(params);
>diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
>index aba3f05..3a05c19 100644
>--- a/fs/cifs/connect.c
>+++ b/fs/cifs/connect.c
>@@ -1,7 +1,7 @@
> /*
>  *   fs/cifs/connect.c
>  *
>- *   Copyright (C) International Business Machines  Corp., 2002,2006
>+ *   Copyright (C) International Business Machines  Corp., 2002,2007
>  *   Author(s): Steve French (sfrench@us.ibm.com)
>  *
>  *   This library is free software; you can redistribute it and/or modify
>@@ -16,7 +16,7 @@
>  *
>  *   You should have received a copy of the GNU Lesser General Public License
>  *   along with this library; if not, write to the Free Software
>- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
>+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>  */
> #include <linux/fs.h>
> #include <linux/net.h>
>@@ -37,6 +37,7 @@
> #include <linux/freezer.h>
> #endif /* 2.6.19 */
> #endif
>+#include <linux/kthread.h>
> #include <asm/uaccess.h>
> #include <asm/processor.h>
> #include "cifspdu.h"
>@@ -56,6 +57,7 @@
> #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 7)
> #define sock_create_kern sock_create
> #endif
>+
> static DECLARE_COMPLETION(cifsd_complete);
> 
> extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
>@@ -88,6 +90,8 @@ struct smb_vol {
> 	unsigned retry:1;
> 	unsigned intr:1;
> 	unsigned setuids:1;
>+	unsigned override_uid:1;
>+	unsigned override_gid:1;
> 	unsigned noperm:1;
> 	unsigned no_psx_acl:1; /* set if posix acl support should be disabled */
> 	unsigned cifs_acl:1;
>@@ -96,6 +100,7 @@ struct smb_vol {
> 	unsigned direct_io:1;
> 	unsigned remap:1;   /* set to remap seven reserved chars in filenames */
> 	unsigned posix_paths:1;   /* unset to not ask for posix pathnames. */
>+	unsigned no_linux_ext:1;
> 	unsigned sfu_emul:1;
> 	unsigned nullauth:1; /* attempt to authenticate with null user */
> 	unsigned nocase;     /* request case insensitive filenames */
>@@ -104,38 +109,38 @@ struct smb_vol {
> 	unsigned int wsize;
> 	unsigned int sockopt;
> 	unsigned short int port;
>-	char * prepath;
>+	char *prepath;
> };
> 
>-static int ipv4_connect(struct sockaddr_in *psin_server, 
>+static int ipv4_connect(struct sockaddr_in *psin_server,
> 			struct socket **csocket,
>-			char * netb_name,
>-			char * server_netb_name);
>-static int ipv6_connect(struct sockaddr_in6 *psin_server, 
>+			char *netb_name,
>+			char *server_netb_name);
>+static int ipv6_connect(struct sockaddr_in6 *psin_server,
> 			struct socket **csocket);
> 
> 
>-	/* 
>+	/*
> 	 * cifs tcp session reconnection
>-	 * 
>+	 *
> 	 * mark tcp session as reconnecting so temporarily locked
> 	 * mark all smb sessions as reconnecting for tcp session
> 	 * reconnect tcp session
> 	 * wake up waiters on reconnection? - (not needed currently)
> 	 */
> 
>-int
>+static int
> cifs_reconnect(struct TCP_Server_Info *server)
> {
> 	int rc = 0;
> 	struct list_head *tmp;
> 	struct cifsSesInfo *ses;
> 	struct cifsTconInfo *tcon;
>-	struct mid_q_entry * mid_entry;
>-	
>+	struct mid_q_entry *mid_entry;
>+
> 	spin_lock(&GlobalMid_Lock);
>-	if(server->tcpStatus == CifsExiting) {
>-		/* the demux thread will exit normally 
>+	if (kthread_should_stop()) {
>+		/* the demux thread will exit normally
> 		next time through the loop */
> 		spin_unlock(&GlobalMid_Lock);
> 		return rc;
>@@ -161,18 +166,18 @@ cifs_reconnect(struct TCP_Server_Info *server)
> 	}
> 	list_for_each(tmp, &GlobalTreeConnectionList) {
> 		tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
>-		if((tcon) && (tcon->ses) && (tcon->ses->server == server)) {
>+		if ((tcon) && (tcon->ses) && (tcon->ses->server == server))
> 			tcon->tidStatus = CifsNeedReconnect;
>-		}
> 	}
> 	read_unlock(&GlobalSMBSeslock);
> 	/* do not want to be sending data on a socket we are freeing */
>-	down(&server->tcpSem); 
>-	if(server->ssocket) {
>-		cFYI(1,("State: 0x%x Flags: 0x%lx", server->ssocket->state,
>+	down(&server->tcpSem);
>+	if (server->ssocket) {
>+		cFYI(1, ("State: 0x%x Flags: 0x%lx", server->ssocket->state,
> 			server->ssocket->flags));
>-		server->ssocket->ops->shutdown(server->ssocket,SEND_SHUTDOWN);
>-		cFYI(1,("Post shutdown state: 0x%x Flags: 0x%lx", server->ssocket->state,
>+		server->ssocket->ops->shutdown(server->ssocket, SEND_SHUTDOWN);
>+		cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx",
>+			server->ssocket->state,
> 			server->ssocket->flags));
> 		sock_release(server->ssocket);
> 		server->ssocket = NULL;
>@@ -183,8 +188,8 @@ cifs_reconnect(struct TCP_Server_Info *server)
> 		mid_entry = list_entry(tmp, struct
> 					mid_q_entry,
> 					qhead);
>-		if(mid_entry) {
>-			if(mid_entry->midState == MID_REQUEST_SUBMITTED) {
>+		if (mid_entry) {
>+			if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
> 				/* Mark other intransit requests as needing
> 				   retry so we do not immediately mark the
> 				   session bad again (ie after we reconnect
>@@ -194,31 +199,31 @@ cifs_reconnect(struct TCP_Server_Info *server)
> 		}
> 	}
> 	spin_unlock(&GlobalMid_Lock);
>-	up(&server->tcpSem); 
>+	up(&server->tcpSem);
> 
>-	while ((server->tcpStatus != CifsExiting) && (server->tcpStatus != CifsGood))
>-	{
>+	while ((!kthread_should_stop()) && (server->tcpStatus != CifsGood)) {
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 12)
> 		try_to_freeze();
> #endif
>-		if(server->protocolType == IPV6) {
>-			rc = ipv6_connect(&server->addr.sockAddr6,&server->ssocket);
>+		if (server->protocolType == IPV6) {
>+			rc = ipv6_connect(&server->addr.sockAddr6,
>+					  &server->ssocket);
> 		} else {
>-			rc = ipv4_connect(&server->addr.sockAddr, 
>+			rc = ipv4_connect(&server->addr.sockAddr,
> 					&server->ssocket,
> 					server->workstation_RFC1001_name,
> 					server->server_RFC1001_name);
> 		}
>-		if(rc) {
>-			cFYI(1,("reconnect error %d",rc));
>+		if (rc) {
>+			cFYI(1, ("reconnect error %d", rc));
> 			msleep(3000);
> 		} else {
> 			atomic_inc(&tcpSesReconnectCount);
> 			spin_lock(&GlobalMid_Lock);
>-			if(server->tcpStatus != CifsExiting)
>+			if (!kthread_should_stop())
> 				server->tcpStatus = CifsGood;
> 			server->sequence_number = 0;
>-			spin_unlock(&GlobalMid_Lock);			
>+			spin_unlock(&GlobalMid_Lock);
> 	/*		atomic_set(&server->inFlight,0);*/
> 			wake_up(&server->response_q);
> 		}
>@@ -226,27 +231,27 @@ cifs_reconnect(struct TCP_Server_Info *server)
> 	return rc;
> }
> 
>-/* 
>+/*
> 	return codes:
> 		0 	not a transact2, or all data present
> 		>0 	transact2 with that much data missing
> 		-EINVAL = invalid transact2
> 
>  */
>-static int check2ndT2(struct smb_hdr * pSMB, unsigned int maxBufSize)
>+static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
> {
>-	struct smb_t2_rsp * pSMBt;
>-        int total_data_size;
>+	struct smb_t2_rsp *pSMBt;
>+	int total_data_size;
> 	int data_in_this_rsp;
> 	int remaining;
> 
>-	if(pSMB->Command != SMB_COM_TRANSACTION2)
>+	if (pSMB->Command != SMB_COM_TRANSACTION2)
> 		return 0;
> 
>-        /* check for plausible wct, bcc and t2 data and parm sizes */
>-        /* check for parm and data offset going beyond end of smb */
>-	if(pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
>-		cFYI(1,("invalid transact2 word count"));
>+	/* check for plausible wct, bcc and t2 data and parm sizes */
>+	/* check for parm and data offset going beyond end of smb */
>+	if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
>+		cFYI(1, ("invalid transact2 word count"));
> 		return -EINVAL;
> 	}
> 
>@@ -257,25 +262,25 @@ static int check2ndT2(struct smb_hdr * pSMB, unsigned int maxBufSize)
> 
> 	remaining = total_data_size - data_in_this_rsp;
> 
>-	if(remaining == 0)
>+	if (remaining == 0)
> 		return 0;
>-	else if(remaining < 0) {
>-		cFYI(1,("total data %d smaller than data in frame %d",
>+	else if (remaining < 0) {
>+		cFYI(1, ("total data %d smaller than data in frame %d",
> 			total_data_size, data_in_this_rsp));
> 		return -EINVAL;
> 	} else {
>-		cFYI(1,("missing %d bytes from transact2, check next response",
>+		cFYI(1, ("missing %d bytes from transact2, check next response",
> 			remaining));
>-		if(total_data_size > maxBufSize) {
>-			cERROR(1,("TotalDataSize %d is over maximum buffer %d",
>-				total_data_size,maxBufSize));
>-			return -EINVAL; 
>+		if (total_data_size > maxBufSize) {
>+			cERROR(1, ("TotalDataSize %d is over maximum buffer %d",
>+				total_data_size, maxBufSize));
>+			return -EINVAL;
> 		}
> 		return remaining;
> 	}
> }
> 
>-static int coalesce_t2(struct smb_hdr * psecond, struct smb_hdr *pTargetSMB)
>+static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
> {
> 	struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
> 	struct smb_t2_rsp *pSMBt  = (struct smb_t2_rsp *)pTargetSMB;
>@@ -283,43 +288,43 @@ static int coalesce_t2(struct smb_hdr * psecond, struct smb_hdr *pTargetSMB)
> 	int total_in_buf;
> 	int remaining;
> 	int total_in_buf2;
>-	char * data_area_of_target;
>-	char * data_area_of_buf2;
>+	char *data_area_of_target;
>+	char *data_area_of_buf2;
> 	__u16 byte_count;
> 
> 	total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
> 
>-	if(total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
>-		cFYI(1,("total data sizes of primary and secondary t2 differ"));
>+	if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
>+		cFYI(1, ("total data size of primary and secondary t2 differ"));
> 	}
> 
> 	total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
> 
> 	remaining = total_data_size - total_in_buf;
>-	
>-	if(remaining < 0)
>+
>+	if (remaining < 0)
> 		return -EINVAL;
> 
>-	if(remaining == 0) /* nothing to do, ignore */
>+	if (remaining == 0) /* nothing to do, ignore */
> 		return 0;
>-	
>+
> 	total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
>-	if(remaining < total_in_buf2) {
>-		cFYI(1,("transact2 2nd response contains too much data"));
>+	if (remaining < total_in_buf2) {
>+		cFYI(1, ("transact2 2nd response contains too much data"));
> 	}
> 
> 	/* find end of first SMB data area */
>-	data_area_of_target = (char *)&pSMBt->hdr.Protocol + 
>+	data_area_of_target = (char *)&pSMBt->hdr.Protocol +
> 				le16_to_cpu(pSMBt->t2_rsp.DataOffset);
> 	/* validate target area */
> 
> 	data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
>-                                        le16_to_cpu(pSMB2->t2_rsp.DataOffset);
>+					le16_to_cpu(pSMB2->t2_rsp.DataOffset);
> 
> 	data_area_of_target += total_in_buf;
> 
> 	/* copy second buffer into end of first buffer */
>-	memcpy(data_area_of_target,data_area_of_buf2,total_in_buf2);
>+	memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
> 	total_in_buf += total_in_buf2;
> 	pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
> 	byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
>@@ -330,11 +335,11 @@ static int coalesce_t2(struct smb_hdr * psecond, struct smb_hdr *pTargetSMB)
> 	byte_count += total_in_buf2;
> 
> 	/* BB also add check that we are not beyond maximum buffer size */
>-		
>+
> 	pTargetSMB->smb_buf_length = byte_count;
> 
>-	if(remaining == total_in_buf2) {
>-		cFYI(1,("found the last secondary response"));
>+	if (remaining == total_in_buf2) {
>+		cFYI(1, ("found the last secondary response"));
> 		return 0; /* we are done */
> 	} else /* more responses to go */
> 		return 1;
>@@ -367,31 +372,30 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
> #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0)
> 	daemonize();
> 	sprintf(current->comm,"cifsd");
>-#else
>-	daemonize("cifsd");
> #endif
>+
> 	current->flags |= PF_MEMALLOC;
> 	server->tsk = current;	/* save process info to wake at shutdown */
> 	cFYI(1, ("Demultiplex PID: %d", current->pid));
>-	write_lock(&GlobalSMBSeslock); 
>+	write_lock(&GlobalSMBSeslock);
> 	atomic_inc(&tcpSesAllocCount);
> 	length = tcpSesAllocCount.counter;
> 	write_unlock(&GlobalSMBSeslock);
> 	complete(&cifsd_complete);
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 10)
>-	if(length  > 1) {
>-		mempool_resize(cifs_req_poolp,
>-			length + cifs_min_rcv,
>-			GFP_KERNEL);
>-	}
>+	if (length  > 1)
>+		mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
>+				GFP_KERNEL);
> #endif
> 
> #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 8)
> 	temp_fs = get_fs();	/* we must turn off socket api parm checking */
> 	set_fs(get_ds());
>+#elif LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22)
>+	set_freezable();
> #endif
> 
>-	while (server->tcpStatus != CifsExiting) {
>+	while (!kthread_should_stop()) {
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 12)
> 		if (try_to_freeze())
> 			continue;
>@@ -406,7 +410,7 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
> 			}
> 		} else if (isLargeBuf) {
> 			/* we are reusing a dirty large buf, clear its start */
>-			memset(bigbuf, 0, sizeof (struct smb_hdr));
>+			memset(bigbuf, 0, sizeof(struct smb_hdr));
> 		}
> 
> 		if (smallbuf == NULL) {
>@@ -419,7 +423,7 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
> 			}
> 			/* beginning of smb buffer is cleared in our buf_get */
> 		} else /* if existing small buf clear beginning */
>-			memset(smallbuf, 0, sizeof (struct smb_hdr));
>+			memset(smallbuf, 0, sizeof(struct smb_hdr));
> 
> 		isLargeBuf = FALSE;
> 		isMultiRsp = FALSE;
>@@ -428,16 +432,20 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
> 		iov.iov_len = 4;
> 		smb_msg.msg_control = NULL;
> 		smb_msg.msg_controllen = 0;
>+		pdu_length = 4; /* enought to get RFC1001 header */
>+incomplete_rcv:
> #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 8)
> 		smb_msg.msg_iov = &iov;
> 		smb_msg.msg_iovlen = 1;
> 		length =
>-			sock_recvmsg(csocket, &smb_msg, 4 /* RFC1001 len */, 0);
>+			sock_recvmsg(csocket, &smb_msg, pdu_length, 0);
> #else
>-		length = kernel_recvmsg(csocket, &smb_msg,
>-				 &iov, 1, 4, 0 /* BB see socket.h flags */);
>+		length =
>+		    kernel_recvmsg(csocket, &smb_msg,
>+				&iov, 1, pdu_length, 0 /* BB other flags? */);
> #endif
>-		if (server->tcpStatus == CifsExiting) {
>+
>+		if (kthread_should_stop()) {
> 			break;
> 		} else if (server->tcpStatus == CifsNeedReconnect) {
> 			cFYI(1, ("Reconnect after server stopped responding"));
>@@ -464,23 +472,21 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
> #else
> 			if (length == -EINTR) {
> #endif
>-				cFYI(1,("cifsd thread killed"));
>+				cFYI(1, ("cifsd thread killed"));
> 				break;
> 			}
>-			cFYI(1,("Reconnect after unexpected peek error %d",
>+			cFYI(1, ("Reconnect after unexpected peek error %d",
> 				length));
> 			cifs_reconnect(server);
> 			csocket = server->ssocket;
> 			wake_up(&server->response_q);
> 			continue;
> 		} else if (length < 4) {
>-			cFYI(1,
>-			    ("Frame under four bytes received (%d bytes long)",
>+			cFYI(1, ("less than four bytes received (%d bytes)",
> 			      length));
>-			cifs_reconnect(server);
>-			csocket = server->ssocket;
>-			wake_up(&server->response_q);
>-			continue;
>+			pdu_length -= length;
>+			msleep(1);
>+			goto incomplete_rcv;
> 		}
> 
> 		/* The right amount was read from socket - 4 bytes */
>@@ -491,26 +497,26 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
> 		with the most common, zero, as regular data */
> 		temp = *((char *) smb_buffer);
> 
>-		/* Note that FC 1001 length is big endian on the wire, 
>+		/* Note that FC 1001 length is big endian on the wire,
> 		but we convert it here so it is always manipulated
> 		as host byte order */
> 		pdu_length = ntohl(smb_buffer->smb_buf_length);
> 		smb_buffer->smb_buf_length = pdu_length;
> 
>-		cFYI(1,("rfc1002 length 0x%x)", pdu_length+4));
>+		cFYI(1, ("rfc1002 length 0x%x", pdu_length+4));
> 
> 		if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
>-			continue; 
>+			continue;
> 		} else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
>-			cFYI(1,("Good RFC 1002 session rsp"));
>+			cFYI(1, ("Good RFC 1002 session rsp"));
> 			continue;
> 		} else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
>-			/* we get this from Windows 98 instead of 
>+			/* we get this from Windows 98 instead of
> 			   an error on SMB negprot response */
>-			cFYI(1,("Negative RFC1002 Session Response Error 0x%x)",
>+			cFYI(1, ("Negative RFC1002 Session Response Error 0x%x)",
> 				pdu_length));
>-			if(server->tcpStatus == CifsNew) {
>-				/* if nack on negprot (rather than 
>+			if (server->tcpStatus == CifsNew) {
>+				/* if nack on negprot (rather than
> 				ret of smb negprot error) reconnecting
> 				not going to help, ret error to mount */
> 				break;
>@@ -520,10 +526,10 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
> 				msleep(1000);
> 				/* always try 445 first on reconnect
> 				since we get NACK on some if we ever
>-				connected to port 139 (the NACK is 
>+				connected to port 139 (the NACK is
> 				since we do not begin with RFC1001
> 				session initialize frame) */
>-				server->addr.sockAddr.sin_port = 
>+				server->addr.sockAddr.sin_port =
> 					htons(CIFS_PORT);
> 				cifs_reconnect(server);
> 				csocket = server->ssocket;
>@@ -531,7 +537,7 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
> 				continue;
> 			}
> 		} else if (temp != (char) 0) {
>-			cERROR(1,("Unknown RFC 1002 frame"));
>+			cERROR(1, ("Unknown RFC 1002 frame"));
> 			cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
> 				      length);
> 			cifs_reconnect(server);
>@@ -540,20 +546,20 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
> 		}
> 
> 		/* else we have an SMB response */
>-		if((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
>-			    (pdu_length < sizeof (struct smb_hdr) - 1 - 4)) {
>+		if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
>+			    (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
> 			cERROR(1, ("Invalid size SMB length %d pdu_length %d",
> 					length, pdu_length+4));
> 			cifs_reconnect(server);
> 			csocket = server->ssocket;
> 			wake_up(&server->response_q);
> 			continue;
>-		} 
>+		}
> 
> 		/* else length ok */
> 		reconnect = 0;
> 
>-		if(pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
>+		if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
> 			isLargeBuf = TRUE;
> 			memcpy(bigbuf, smallbuf, 4);
> 			smb_buffer = bigbuf;
>@@ -561,7 +567,7 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
> 		length = 0;
> 		iov.iov_base = 4 + (char *)smb_buffer;
> 		iov.iov_len = pdu_length;
>-		for (total_read = 0; total_read < pdu_length; 
>+		for (total_read = 0; total_read < pdu_length;
> 		     total_read += length) {
> #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 8)
> 			length = sock_recvmsg(csocket, &smb_msg,
>@@ -570,7 +576,7 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
> 			length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
> 						pdu_length - total_read, 0);
> #endif
>-			if((server->tcpStatus == CifsExiting) ||
>+			if (kthread_should_stop() ||
> 			    (length == -EINTR)) {
> 				/* then will exit */
> 				reconnect = 2;
>@@ -578,20 +584,19 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
> 			} else if (server->tcpStatus == CifsNeedReconnect) {
> 				cifs_reconnect(server);
> 				csocket = server->ssocket;
>-			        /* Reconnect wakes up rspns q */
>+				/* Reconnect wakes up rspns q */
> 				/* Now we will reread sock */
> 				reconnect = 1;
> 				break;
>-			} else if ((length == -ERESTARTSYS) || 
>+			} else if ((length == -ERESTARTSYS) ||
> 				   (length == -EAGAIN)) {
> 				msleep(1); /* minimum sleep to prevent looping,
>-                                              allowing socket to clear and app 
>+					      allowing socket to clear and app
> 					      threads to set tcpStatus
> 					      CifsNeedReconnect if server hung*/
>-				length = 0;
> 				continue;
> 			} else if (length <= 0) {
>-				cERROR(1,("Received no data, expecting %d",
>+				cERROR(1, ("Received no data, expecting %d",
> 					      pdu_length - total_read));
> 				cifs_reconnect(server);
> 				csocket = server->ssocket;
>@@ -599,13 +604,13 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
> 				break;
> 			}
> 		}
>-		if(reconnect == 2)
>+		if (reconnect == 2)
> 			break;
>-		else if(reconnect == 1)
>+		else if (reconnect == 1)
> 			continue;
> 
> 		length += 4; /* account for rfc1002 hdr */
>-	
>+
> 
> 		dump_smb(smb_buffer, length);
> 		if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
>@@ -619,28 +624,28 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
> 		list_for_each(tmp, &server->pending_mid_q) {
> 			mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
> 
>-			if ((mid_entry->mid == smb_buffer->Mid) && 
>+			if ((mid_entry->mid == smb_buffer->Mid) &&
> 			    (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
> 			    (mid_entry->command == smb_buffer->Command)) {
>-				if(check2ndT2(smb_buffer,server->maxBuf) > 0) {
>+				if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
> 					/* We have a multipart transact2 resp */
> 					isMultiRsp = TRUE;
>-					if(mid_entry->resp_buf) {
>+					if (mid_entry->resp_buf) {
> 						/* merge response - fix up 1st*/
>-						if(coalesce_t2(smb_buffer, 
>+						if (coalesce_t2(smb_buffer,
> 							mid_entry->resp_buf)) {
> 							mid_entry->multiRsp = 1;
> 							break;
> 						} else {
> 							/* all parts received */
> 							mid_entry->multiEnd = 1;
>-							goto multi_t2_fnd; 
>+							goto multi_t2_fnd;
> 						}
> 					} else {
>-						if(!isLargeBuf) {
>+						if (!isLargeBuf) {
> 							cERROR(1,("1st trans2 resp needs bigbuf"));
> 					/* BB maybe we can fix this up,  switch
>-				   	   to already allocated large buffer? */
>+					   to already allocated large buffer? */
> 						} else {
> 							/* Have first buffer */
> 							mid_entry->resp_buf =
>@@ -650,9 +655,9 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
> 						}
> 					}
> 					break;
>-				} 
>+				}
> 				mid_entry->resp_buf = smb_buffer;
>-				if(isLargeBuf)
>+				if (isLargeBuf)
> 					mid_entry->largeBuf = 1;
> 				else
> 					mid_entry->largeBuf = 0;
>@@ -672,24 +677,25 @@ multi_t2_fnd:
> 		spin_unlock(&GlobalMid_Lock);
> 		if (task_to_wake) {
> 			/* Was previous buf put in mpx struct for multi-rsp? */
>-			if(!isMultiRsp) {
>+			if (!isMultiRsp) {
> 				/* smb buffer will be freed by user thread */
>-				if(isLargeBuf) {
>+				if (isLargeBuf)
> 					bigbuf = NULL;
>-				} else
>+				else
> 					smallbuf = NULL;
> 			}
> 			wake_up_process(task_to_wake);
> 		} else if ((is_valid_oplock_break(smb_buffer, server) == FALSE)
>-		    && (isMultiRsp == FALSE)) {                          
>-			cERROR(1, ("No task to wake, unknown frame rcvd! NumMids %d", midCount.counter));
>-			cifs_dump_mem("Received Data is: ",(char *)smb_buffer,
>+		    && (isMultiRsp == FALSE)) {
>+			cERROR(1, ("No task to wake, unknown frame received! "
>+				   "NumMids %d", midCount.counter));
>+			cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
> 				      sizeof(struct smb_hdr));
> #ifdef CONFIG_CIFS_DEBUG2
> 			cifs_dump_detail(smb_buffer);
> 			cifs_dump_mids(server);
> #endif /* CIFS_DEBUG2 */
>-			
>+
> 		}
> 	} /* end while !EXITING */
> 
>@@ -699,12 +705,12 @@ multi_t2_fnd:
> 	/* check if we have blocked requests that need to free */
> 	/* Note that cifs_max_pending is normally 50, but
> 	can be set at module install time to as little as two */
>-	if(atomic_read(&server->inFlight) >= cifs_max_pending)
>+	if (atomic_read(&server->inFlight) >= cifs_max_pending)
> 		atomic_set(&server->inFlight, cifs_max_pending - 1);
> 	/* We do not want to set the max_pending too low or we
> 	could end up with the counter going negative */
> 	spin_unlock(&GlobalMid_Lock);
>-	/* Although there should not be any requests blocked on 
>+	/* Although there should not be any requests blocked on
> 	this queue it can not hurt to be paranoid and try to wake up requests
> 	that may haven been blocked when more than 50 at time were on the wire
> 	to the same server - they now will see the session is in exit state
>@@ -712,12 +718,11 @@ multi_t2_fnd:
> 	wake_up_all(&server->request_q);
> 	/* give those requests time to exit */
> 	msleep(125);
>-	
>-	if(server->ssocket) {
>+
>+	if (server->ssocket) {
> 		sock_release(csocket);
> 		server->ssocket = NULL;
> 	}
>-
> #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 8)
> 	set_fs(temp_fs);
> #endif
>@@ -748,21 +753,19 @@ multi_t2_fnd:
> 		list_for_each(tmp, &GlobalSMBSessionList) {
> 			ses = list_entry(tmp, struct cifsSesInfo,
> 					 cifsSessionList);
>-			if (ses->server == server) {
>+			if (ses->server == server)
> 				ses->status = CifsExiting;
>-			}
> 		}
> 
> 		spin_lock(&GlobalMid_Lock);
> 		list_for_each(tmp, &server->pending_mid_q) {
> 		mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
> 			if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
>-				cFYI(1,
>-				  ("Clearing Mid 0x%x - waking up ",mid_entry->mid));
>+				cFYI(1, ("Clearing Mid 0x%x - waking up ",
>+					 mid_entry->mid));
> 				task_to_wake = mid_entry->tsk;
>-				if(task_to_wake) {
>+				if (task_to_wake)
> 					wake_up_process(task_to_wake);
>-				}
> 			}
> 		}
> 		spin_unlock(&GlobalMid_Lock);
>@@ -772,7 +775,7 @@ multi_t2_fnd:
> 	}
> 
> 	if (!list_empty(&server->pending_mid_q)) {
>-		/* mpx threads have not exited yet give them 
>+		/* mpx threads have not exited yet give them
> 		at least the smb send timeout time for long ops */
> 		/* due to delays on oplock break requests, we need
> 		to wait at least 45 seconds before giving up
>@@ -790,32 +793,30 @@ multi_t2_fnd:
> 
> 	/* last chance to mark ses pointers invalid
> 	if there are any pointing to this (e.g
>-	if a crazy root user tried to kill cifsd 
>+	if a crazy root user tried to kill cifsd
> 	kernel thread explicitly this might happen) */
> 	list_for_each(tmp, &GlobalSMBSessionList) {
> 		ses = list_entry(tmp, struct cifsSesInfo,
> 				cifsSessionList);
>-		if (ses->server == server) {
>+		if (ses->server == server)
> 			ses->server = NULL;
>-		}
> 	}
> 	write_unlock(&GlobalSMBSeslock);
> 
> 	kfree(server);
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
>-	if(length  > 0) {
>-		mempool_resize(cifs_req_poolp,
>-			length + cifs_min_rcv,
>-			GFP_KERNEL);
>-	}
>+	if (length  > 0)
>+		mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
>+				GFP_KERNEL);
> #endif
>-	
>-	complete_and_exit(&cifsd_complete, 0);
>+
>+	/* BB PORT - do we need complete_and_exit here? BB */
> 	return 0;
> }
> 
> static int
>-cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
>+cifs_parse_mount_options(char *options, const char *devname,
>+			 struct smb_vol *vol)
> {
> 	char *value;
> 	char *data;
>@@ -823,24 +824,24 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
> 	char separator[2];
> 
> 	separator[0] = ',';
>-	separator[1] = 0; 
>+	separator[1] = 0;
> 
>-	memset(vol->source_rfc1001_name,0x20,15);
>+	if (Local_System_Name[0] != 0)
>+		memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
>+	else {
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 18)
>-	for(i=0;i < strnlen(utsname()->nodename,15);i++) {
>-		/* does not have to be a perfect mapping since the field is
>-		informational, only used for servers that do not support
>-		port 445 and it can be overridden at mount time */
>-		vol->source_rfc1001_name[i] = 
>-			toupper(utsname()->nodename[i]);
>+		char *nodename = utsname()->nodename;
> #else
>-	for(i=0;i < strnlen(system_utsname.nodename,15);i++) {
>-		/* does not have to be a perfect mapping since the field is
>-		informational, only used for servers that do not support
>-		port 445 and it can be overridden at mount time */
>-		vol->source_rfc1001_name[i] = 
>-			toupper(system_utsname.nodename[i]);
>+		char *nodename = system_utsname.nodename;
> #endif
>+		int n = strnlen(nodename, 15);
>+		memset(vol->source_rfc1001_name, 0x20, 15);
>+		for (i = 0; i < n; i++) {
>+			/* does not have to be perfect mapping since field is
>+			informational, only used for servers that do not support
>+			port 445 and it can be overridden at mount time */
>+			vol->source_rfc1001_name[i] = toupper(nodename[i]);
>+		}
> 	}
> 	vol->source_rfc1001_name[15] = 0;
> 	/* null target name indicates to use *SMBSERVR default called name
>@@ -860,31 +861,32 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
> 	if (!options)
> 		return 1;
> 
>-	if(strncmp(options,"sep=",4) == 0) {
>-		if(options[4] != 0) {
>+	if (strncmp(options, "sep=", 4) == 0) {
>+		if (options[4] != 0) {
> 			separator[0] = options[4];
> 			options += 5;
> 		} else {
>-			cFYI(1,("Null separator not allowed"));
>+			cFYI(1, ("Null separator not allowed"));
> 		}
> 	}
>-		
>+
> 	while ((data = strsep(&options, separator)) != NULL) {
> 		if (!*data)
> 			continue;
> 		if ((value = strchr(data, '=')) != NULL)
> 			*value++ = '\0';
> 
>-		if (strnicmp(data, "user_xattr",10) == 0) {/*parse before user*/
>+		/* Have to parse this before we parse for "user" */
>+		if (strnicmp(data, "user_xattr", 10) == 0) {
> 			vol->no_xattr = 0;
>-		} else if (strnicmp(data, "nouser_xattr",12) == 0) {
>+		} else if (strnicmp(data, "nouser_xattr", 12) == 0) {
> 			vol->no_xattr = 1;
> 		} else if (strnicmp(data, "user", 4) == 0) {
> 			if (!value) {
> 				printk(KERN_WARNING
> 				       "CIFS: invalid or missing username\n");
> 				return 1;	/* needs_arg; */
>-			} else if(!*value) {
>+			} else if (!*value) {
> 				/* null user, ie anonymous, authentication */
> 				vol->nullauth = 1;
> 			}
>@@ -898,12 +900,12 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
> 			if (!value) {
> 				vol->password = NULL;
> 				continue;
>-			} else if(value[0] == 0) {
>+			} else if (value[0] == 0) {
> 				/* check if string begins with double comma
> 				   since that would mean the password really
> 				   does start with a comma, and would not
> 				   indicate an empty string */
>-				if(value[1] != separator[0]) {
>+				if (value[1] != separator[0]) {
> 					vol->password = NULL;
> 					continue;
> 				}
>@@ -912,7 +914,7 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
> 			/* removed password length check, NTLM passwords
> 				can be arbitrarily long */
> 
>-			/* if comma in password, the string will be 
>+			/* if comma in password, the string will be
> 			prematurely null terminated.  Commas in password are
> 			specified across the cifs mount interface by a double
> 			comma ie ,, and a comma used as in other cases ie ','
>@@ -922,18 +924,18 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
> 			/* NB: password legally can have multiple commas and
> 			the only illegal character in a password is null */
> 
>-			if ((value[temp_len] == 0) && 
>+			if ((value[temp_len] == 0) &&
> 			    (value[temp_len+1] == separator[0])) {
> 				/* reinsert comma */
> 				value[temp_len] = separator[0];
>-				temp_len+=2;  /* move after the second comma */
>-				while(value[temp_len] != 0)  {
>+				temp_len += 2;  /* move after second comma */
>+				while (value[temp_len] != 0)  {
> 					if (value[temp_len] == separator[0]) {
>-						if (value[temp_len+1] == 
>+						if (value[temp_len+1] ==
> 						     separator[0]) {
> 						/* skip second comma */
> 							temp_len++;
>-						} else { 
>+						} else {
> 						/* single comma indicating start
> 							 of next parm */
> 							break;
>@@ -941,24 +943,25 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
> 					}
> 					temp_len++;
> 				}
>-				if(value[temp_len] == 0) {
>+				if (value[temp_len] == 0) {
> 					options = NULL;
> 				} else {
> 					value[temp_len] = 0;
> 					/* point option to start of next parm */
> 					options = value + temp_len + 1;
> 				}
>-				/* go from value to value + temp_len condensing 
>+				/* go from value to value + temp_len condensing
> 				double commas to singles. Note that this ends up
> 				allocating a few bytes too many, which is ok */
> 				vol->password = kzalloc(temp_len, GFP_KERNEL);
>-				if(vol->password == NULL) {
>-					printk("CIFS: no memory for pass\n");
>+				if (vol->password == NULL) {
>+					printk(KERN_WARNING "CIFS: no memory "
>+							    "for password\n");
> 					return 1;
> 				}
>-				for(i=0,j=0;i<temp_len;i++,j++) {
>+				for (i = 0, j = 0; i < temp_len; i++, j++) {
> 					vol->password[j] = value[i];
>-					if(value[i] == separator[0]
>+					if (value[i] == separator[0]
> 						&& value[i+1] == separator[0]) {
> 						/* skip second comma */
> 						i++;
>@@ -967,8 +970,9 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
> 				vol->password[j] = 0;
> 			} else {
> 				vol->password = kzalloc(temp_len+1, GFP_KERNEL);
>-				if(vol->password == NULL) {
>-					printk("CIFS: no memory for pass\n");
>+				if (vol->password == NULL) {
>+					printk(KERN_WARNING "CIFS: no memory "
>+							    "for password\n");
> 					return 1;
> 				}
> 				strcpy(vol->password, value);
>@@ -979,20 +983,21 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
> 			} else if (strnlen(value, 35) < 35) {
> 				vol->UNCip = value;
> 			} else {
>-				printk(KERN_WARNING "CIFS: ip address too long\n");
>+				printk(KERN_WARNING "CIFS: ip address "
>+						    "too long\n");
> 				return 1;
> 			}
>-                } else if (strnicmp(data, "sec", 3) == 0) { 
>-                        if (!value || !*value) {
>-				cERROR(1,("no security value specified"));
>-                                continue;
>-                        } else if (strnicmp(value, "krb5i", 5) == 0) {
>-				vol->secFlg |= CIFSSEC_MAY_KRB5 | 
>+		} else if (strnicmp(data, "sec", 3) == 0) {
>+			if (!value || !*value) {
>+				cERROR(1, ("no security value specified"));
>+				continue;
>+			} else if (strnicmp(value, "krb5i", 5) == 0) {
>+				vol->secFlg |= CIFSSEC_MAY_KRB5 |
> 					CIFSSEC_MUST_SIGN;
> 			} else if (strnicmp(value, "krb5p", 5) == 0) {
>-				/* vol->secFlg |= CIFSSEC_MUST_SEAL | 
>-					CIFSSEC_MAY_KRB5; */ 
>-				cERROR(1,("Krb5 cifs privacy not supported"));
>+				/* vol->secFlg |= CIFSSEC_MUST_SEAL |
>+					CIFSSEC_MAY_KRB5; */
>+				cERROR(1, ("Krb5 cifs privacy not supported"));
> 				return 1;
> 			} else if (strnicmp(value, "krb5", 4) == 0) {
> 				vol->secFlg |= CIFSSEC_MAY_KRB5;
>@@ -1012,33 +1017,34 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
> 				vol->secFlg |= CIFSSEC_MAY_NTLMV2;
> #ifdef CONFIG_CIFS_WEAK_PW_HASH
> 			} else if (strnicmp(value, "lanman", 6) == 0) {
>-                                vol->secFlg |= CIFSSEC_MAY_LANMAN;
>+				vol->secFlg |= CIFSSEC_MAY_LANMAN;
> #endif
> 			} else if (strnicmp(value, "none", 4) == 0) {
> 				vol->nullauth = 1;
>-                        } else {
>-                                cERROR(1,("bad security option: %s", value));
>-                                return 1;
>-                        }
>+			} else {
>+				cERROR(1, ("bad security option: %s", value));
>+				return 1;
>+			}
> 		} else if ((strnicmp(data, "unc", 3) == 0)
> 			   || (strnicmp(data, "target", 6) == 0)
> 			   || (strnicmp(data, "path", 4) == 0)) {
> 			if (!value || !*value) {
>-				printk(KERN_WARNING
>-				       "CIFS: invalid path to network resource\n");
>+				printk(KERN_WARNING "CIFS: invalid path to "
>+						    "network resource\n");
> 				return 1;	/* needs_arg; */
> 			}
> 			if ((temp_len = strnlen(value, 300)) < 300) {
>-				vol->UNC = kmalloc(temp_len+1,GFP_KERNEL);
>-				if(vol->UNC == NULL)
>+				vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
>+				if (vol->UNC == NULL)
> 					return 1;
>-				strcpy(vol->UNC,value);
>+				strcpy(vol->UNC, value);
> 				if (strncmp(vol->UNC, "//", 2) == 0) {
> 					vol->UNC[0] = '\\';
> 					vol->UNC[1] = '\\';
>-				} else if (strncmp(vol->UNC, "\\\\", 2) != 0) {	                   
>+				} else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
> 					printk(KERN_WARNING
>-					       "CIFS: UNC Path does not begin with // or \\\\ \n");
>+					       "CIFS: UNC Path does not begin "
>+					       "with // or \\\\ \n");
> 					return 1;
> 				}
> 			} else {
>@@ -1057,54 +1063,60 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
> 				vol->domainname = value;
> 				cFYI(1, ("Domain name set"));
> 			} else {
>-				printk(KERN_WARNING "CIFS: domain name too long\n");
>+				printk(KERN_WARNING "CIFS: domain name too "
>+						    "long\n");
> 				return 1;
> 			}
>-                } else if (strnicmp(data, "prefixpath", 10) == 0) {
>-                        if (!value || !*value) {
>-                                printk(KERN_WARNING
>-                                       "CIFS: invalid path prefix\n");
>-                                return 1;       /* needs_arg; */
>-                        }
>-                        if ((temp_len = strnlen(value, 1024)) < 1024) {
>-				if(value[0] != '/')
>+		} else if (strnicmp(data, "prefixpath", 10) == 0) {
>+			if (!value || !*value) {
>+				printk(KERN_WARNING
>+					"CIFS: invalid path prefix\n");
>+				return 1;       /* needs_argument */
>+			}
>+			if ((temp_len = strnlen(value, 1024)) < 1024) {
>+				if (value[0] != '/')
> 					temp_len++;  /* missing leading slash */
>-                                vol->prepath = kmalloc(temp_len+1,GFP_KERNEL);
>-                                if(vol->prepath == NULL)
>-                                        return 1;
>-				if(value[0] != '/') {
>+				vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
>+				if (vol->prepath == NULL)
>+					return 1;
>+				if (value[0] != '/') {
> 					vol->prepath[0] = '/';
>-	                                strcpy(vol->prepath+1,value);
>+					strcpy(vol->prepath+1, value);
> 				} else
>-					strcpy(vol->prepath,value);
>-				cFYI(1,("prefix path %s",vol->prepath));
>-                        } else {
>-                                printk(KERN_WARNING "CIFS: prefix too long\n");
>-                                return 1;
>-                        }
>+					strcpy(vol->prepath, value);
>+				cFYI(1, ("prefix path %s", vol->prepath));
>+			} else {
>+				printk(KERN_WARNING "CIFS: prefix too long\n");
>+				return 1;
>+			}
> 		} else if (strnicmp(data, "iocharset", 9) == 0) {
> 			if (!value || !*value) {
>-				printk(KERN_WARNING "CIFS: invalid iocharset specified\n");
>+				printk(KERN_WARNING "CIFS: invalid iocharset "
>+						    "specified\n");
> 				return 1;	/* needs_arg; */
> 			}
> 			if (strnlen(value, 65) < 65) {
>-				if(strnicmp(value,"default",7))
>+				if (strnicmp(value, "default", 7))
> 					vol->iocharset = value;
>-				/* if iocharset not set load_nls_default used by caller */
>-				cFYI(1, ("iocharset set to %s",value));
>+				/* if iocharset not set then load_nls_default
>+				   is used by caller */
>+				cFYI(1, ("iocharset set to %s", value));
> 			} else {
>-				printk(KERN_WARNING "CIFS: iocharset name too long.\n");
>+				printk(KERN_WARNING "CIFS: iocharset name "
>+						    "too long.\n");
> 				return 1;
> 			}
> 		} else if (strnicmp(data, "uid", 3) == 0) {
> 			if (value && *value) {
> 				vol->linux_uid =
> 					simple_strtoul(value, &value, 0);
>+				vol->override_uid = 1;
> 			}
> 		} else if (strnicmp(data, "gid", 3) == 0) {
> 			if (value && *value) {
> 				vol->linux_gid =
> 					simple_strtoul(value, &value, 0);
>+				vol->override_gid = 1;
> 			}
> 		} else if (strnicmp(data, "file_mode", 4) == 0) {
> 			if (value && *value) {
>@@ -1143,54 +1155,59 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
> 			}
> 		} else if (strnicmp(data, "netbiosname", 4) == 0) {
> 			if (!value || !*value || (*value == ' ')) {
>-				cFYI(1,("invalid (empty) netbiosname specified"));
>+				cFYI(1, ("invalid (empty) netbiosname"));
> 			} else {
>-				memset(vol->source_rfc1001_name,0x20,15);
>-				for(i=0;i<15;i++) {
>-				/* BB are there cases in which a comma can be 
>+				memset(vol->source_rfc1001_name, 0x20, 15);
>+				for (i = 0; i < 15; i++) {
>+				/* BB are there cases in which a comma can be
> 				valid in this workstation netbios name (and need
> 				special handling)? */
> 
> 				/* We do not uppercase netbiosname for user */
>-					if (value[i]==0)
>+					if (value[i] == 0)
> 						break;
>-					else 
>-						vol->source_rfc1001_name[i] = value[i];
>+					else
>+						vol->source_rfc1001_name[i] =
>+								value[i];
> 				}
> 				/* The string has 16th byte zero still from
> 				set at top of the function  */
>-				if((i==15) && (value[i] != 0))
>-					printk(KERN_WARNING "CIFS: netbiosname longer than 15 truncated.\n");
>+				if ((i == 15) && (value[i] != 0))
>+					printk(KERN_WARNING "CIFS: netbiosname"
>+						" longer than 15 truncated.\n");
> 			}
> 		} else if (strnicmp(data, "servern", 7) == 0) {
> 			/* servernetbiosname specified override *SMBSERVER */
> 			if (!value || !*value || (*value == ' ')) {
>-				cFYI(1,("empty server netbiosname specified"));
>+				cFYI(1, ("empty server netbiosname specified"));
> 			} else {
> 				/* last byte, type, is 0x20 for servr type */
>-				memset(vol->target_rfc1001_name,0x20,16);
>+				memset(vol->target_rfc1001_name, 0x20, 16);
> 
>-				for(i=0;i<15;i++) {
>+				for (i = 0; i < 15; i++) {
> 				/* BB are there cases in which a comma can be
>-				   valid in this workstation netbios name (and need
>-				   special handling)? */
>+				   valid in this workstation netbios name
>+				   (and need special handling)? */
> 
>-				/* user or mount helper must uppercase netbiosname */
>-					if (value[i]==0)
>+				/* user or mount helper must uppercase
>+				   the netbiosname */
>+					if (value[i] == 0)
> 						break;
> 					else
>-						vol->target_rfc1001_name[i] = value[i];
>+						vol->target_rfc1001_name[i] =
>+								value[i];
> 				}
> 				/* The string has 16th byte zero still from
> 				   set at top of the function  */
>-				if((i==15) && (value[i] != 0))
>-					printk(KERN_WARNING "CIFS: server netbiosname longer than 15 truncated.\n");
>+				if ((i == 15) && (value[i] != 0))
>+					printk(KERN_WARNING "CIFS: server net"
>+					"biosname longer than 15 truncated.\n");
> 			}
> 		} else if (strnicmp(data, "credentials", 4) == 0) {
> 			/* ignore */
> 		} else if (strnicmp(data, "version", 3) == 0) {
> 			/* ignore */
>-		} else if (strnicmp(data, "guest",5) == 0) {
>+		} else if (strnicmp(data, "guest", 5) == 0) {
> 			/* ignore */
> 		} else if (strnicmp(data, "rw", 2) == 0) {
> 			vol->rw = TRUE;
>@@ -1202,11 +1219,11 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
> 				   (strnicmp(data, "noauto", 6) == 0) ||
> 				   (strnicmp(data, "dev", 3) == 0)) {
> 			/*  The mount tool or mount.cifs helper (if present)
>-				uses these opts to set flags, and the flags are read
>-				by the kernel vfs layer before we get here (ie
>-				before read super) so there is no point trying to
>-				parse these options again and set anything and it
>-				is ok to just ignore them */
>+			    uses these opts to set flags, and the flags are read
>+			    by the kernel vfs layer before we get here (ie
>+			    before read super) so there is no point trying to
>+			    parse these options again and set anything and it
>+			    is ok to just ignore them */
> 			continue;
> 		} else if (strnicmp(data, "ro", 2) == 0) {
> 			vol->rw = FALSE;
>@@ -1222,26 +1239,31 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
> 			vol->remap = 1;
> 		} else if (strnicmp(data, "nomapchars", 10) == 0) {
> 			vol->remap = 0;
>-                } else if (strnicmp(data, "sfu", 3) == 0) {
>-                        vol->sfu_emul = 1;
>-                } else if (strnicmp(data, "nosfu", 5) == 0) {
>-                        vol->sfu_emul = 0;
>+		} else if (strnicmp(data, "sfu", 3) == 0) {
>+			vol->sfu_emul = 1;
>+		} else if (strnicmp(data, "nosfu", 5) == 0) {
>+			vol->sfu_emul = 0;
> 		} else if (strnicmp(data, "posixpaths", 10) == 0) {
> 			vol->posix_paths = 1;
> 		} else if (strnicmp(data, "noposixpaths", 12) == 0) {
> 			vol->posix_paths = 0;
>-                } else if ((strnicmp(data, "nocase", 6) == 0) ||
>+		} else if (strnicmp(data, "nounix", 6) == 0) {
>+			vol->no_linux_ext = 1;
>+		} else if (strnicmp(data, "nolinux", 7) == 0) {
>+			vol->no_linux_ext = 1;
>+		} else if ((strnicmp(data, "nocase", 6) == 0) ||
> 			   (strnicmp(data, "ignorecase", 10)  == 0)) {
>-                        vol->nocase = 1;
>+			vol->nocase = 1;
> 		} else if (strnicmp(data, "brl", 3) == 0) {
> 			vol->nobrl =  0;
>-		} else if ((strnicmp(data, "nobrl", 5) == 0) || 
>+		} else if ((strnicmp(data, "nobrl", 5) == 0) ||
> 			   (strnicmp(data, "nolock", 6) == 0)) {
> 			vol->nobrl =  1;
> 			/* turn off mandatory locking in mode
> 			if remote locking is turned off since the
> 			local vfs will do advisory */
>-			if(vol->file_mode == (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
>+			if (vol->file_mode ==
>+				(S_IALLUGO & ~(S_ISUID | S_IXGRP)))
> 				vol->file_mode = S_IALLUGO;
> 		} else if (strnicmp(data, "setuids", 7) == 0) {
> 			vol->setuids = 1;
>@@ -1255,55 +1277,61 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
> 			vol->intr = 0;
> 		} else if (strnicmp(data, "intr", 4) == 0) {
> 			vol->intr = 1;
>-		} else if (strnicmp(data, "serverino",7) == 0) {
>+		} else if (strnicmp(data, "serverino", 7) == 0) {
> 			vol->server_ino = 1;
>-		} else if (strnicmp(data, "noserverino",9) == 0) {
>+		} else if (strnicmp(data, "noserverino", 9) == 0) {
> 			vol->server_ino = 0;
>-		} else if (strnicmp(data, "cifsacl",7) == 0) {
>+		} else if (strnicmp(data, "cifsacl", 7) == 0) {
> 			vol->cifs_acl = 1;
> 		} else if (strnicmp(data, "nocifsacl", 9) == 0) {
> 			vol->cifs_acl = 0;
>-		} else if (strnicmp(data, "acl",3) == 0) {
>+		} else if (strnicmp(data, "acl", 3) == 0) {
> 			vol->no_psx_acl = 0;
>-		} else if (strnicmp(data, "noacl",5) == 0) {
>+		} else if (strnicmp(data, "noacl", 5) == 0) {
> 			vol->no_psx_acl = 1;
>-		} else if (strnicmp(data, "sign",4) == 0) {
>+		} else if (strnicmp(data, "sign", 4) == 0) {
> 			vol->secFlg |= CIFSSEC_MUST_SIGN;
> /*		} else if (strnicmp(data, "seal",4) == 0) {
> 			vol->secFlg |= CIFSSEC_MUST_SEAL; */
>-		} else if (strnicmp(data, "direct",6) == 0) {
>+		} else if (strnicmp(data, "direct", 6) == 0) {
> 			vol->direct_io = 1;
>-		} else if (strnicmp(data, "forcedirectio",13) == 0) {
>+		} else if (strnicmp(data, "forcedirectio", 13) == 0) {
> 			vol->direct_io = 1;
>-		} else if (strnicmp(data, "in6_addr",8) == 0) {
>+		} else if (strnicmp(data, "in6_addr", 8) == 0) {
> 			if (!value || !*value) {
> 				vol->in6_addr = NULL;
> 			} else if (strnlen(value, 49) == 48) {
> 				vol->in6_addr = value;
> 			} else {
>-				printk(KERN_WARNING "CIFS: ip v6 address not 48 characters long\n");
>+				printk(KERN_WARNING "CIFS: ip v6 address not "
>+						    "48 characters long\n");
> 				return 1;
> 			}
> 		} else if (strnicmp(data, "noac", 4) == 0) {
>-			printk(KERN_WARNING "CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
>+			printk(KERN_WARNING "CIFS: Mount option noac not "
>+				"supported. Instead set "
>+				"/proc/fs/cifs/LookupCacheEnabled to 0\n");
> 		} else
>-			printk(KERN_WARNING "CIFS: Unknown mount option %s\n",data);
>+			printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
>+						data);
> 	}
> 	if (vol->UNC == NULL) {
>-		if(devname == NULL) {
>-			printk(KERN_WARNING "CIFS: Missing UNC name for mount target\n");
>+		if (devname == NULL) {
>+			printk(KERN_WARNING "CIFS: Missing UNC name for mount "
>+						"target\n");
> 			return 1;
> 		}
> 		if ((temp_len = strnlen(devname, 300)) < 300) {
>-			vol->UNC = kmalloc(temp_len+1,GFP_KERNEL);
>-			if(vol->UNC == NULL)
>+			vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
>+			if (vol->UNC == NULL)
> 				return 1;
>-			strcpy(vol->UNC,devname);
>+			strcpy(vol->UNC, devname);
> 			if (strncmp(vol->UNC, "//", 2) == 0) {
> 				vol->UNC[0] = '\\';
> 				vol->UNC[1] = '\\';
> 			} else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
>-				printk(KERN_WARNING "CIFS: UNC Path does not begin with // or \\\\ \n");
>+				printk(KERN_WARNING "CIFS: UNC Path does not "
>+						    "begin with // or \\\\ \n");
> 				return 1;
> 			}
> 		} else {
>@@ -1311,14 +1339,14 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
> 			return 1;
> 		}
> 	}
>-	if(vol->UNCip == NULL)
>+	if (vol->UNCip == NULL)
> 		vol->UNCip = &vol->UNC[2];
> 
> 	return 0;
> }
> 
> static struct cifsSesInfo *
>-cifs_find_tcp_session(struct in_addr * target_ip_addr, 
>+cifs_find_tcp_session(struct in_addr *target_ip_addr,
> 		struct in6_addr *target_ip6_addr,
> 		 char *userName, struct TCP_Server_Info **psrvTcp)
> {
>@@ -1330,19 +1358,25 @@ cifs_find_tcp_session(struct in_addr * target_ip_addr,
> 	list_for_each(tmp, &GlobalSMBSessionList) {
> 		ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
> 		if (ses->server) {
>-			if((target_ip_addr && 
>+			if ((target_ip_addr &&
> 				(ses->server->addr.sockAddr.sin_addr.s_addr
> 				  == target_ip_addr->s_addr)) || (target_ip6_addr
> 				&& memcmp(&ses->server->addr.sockAddr6.sin6_addr,
>-					target_ip6_addr,sizeof(*target_ip6_addr)))){
>-				/* BB lock server and tcp session and increment use count here?? */
>-				*psrvTcp = ses->server;	/* found a match on the TCP session */
>+					target_ip6_addr, sizeof(*target_ip6_addr)))) {
>+				/* BB lock server and tcp session and increment
>+				      use count here?? */
>+
>+				/* found a match on the TCP session */
>+				*psrvTcp = ses->server;
>+
> 				/* BB check if reconnection needed */
> 				if (strncmp
> 				    (ses->userName, userName,
> 				     MAX_USERNAME_SIZE) == 0){
> 					read_unlock(&GlobalSMBSeslock);
>-					return ses;	/* found exact match on both tcp and SMB sessions */
>+					/* Found exact match on both TCP and
>+					   SMB sessions */
>+					return ses;
> 				}
> 			}
> 		}
>@@ -1373,7 +1407,8 @@ find_unc(__be32 new_target_ip_addr, char *uncName, char *userName)
> 	/* BB lock tcon, server and tcp session and increment use count here? */
> 					/* found a match on the TCP session */
> 					/* BB check if reconnection needed */
>-					cFYI(1,("IP match, old UNC: %s new: %s",
>+					cFYI(1,
>+					      ("IP match, old UNC: %s new: %s",
> 					      tcon->treeName, uncName));
> 					if (strncmp
> 					    (tcon->treeName, uncName,
>@@ -1408,11 +1443,11 @@ connect_to_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
> 	unsigned int num_referrals;
> 	int rc = 0;
> 
>-	rc = get_dfs_path(xid, pSesInfo,old_path, nls_codepage, 
>+	rc = get_dfs_path(xid, pSesInfo, old_path, nls_codepage,
> 			&num_referrals, &referrals, remap);
> 
> 	/* BB Add in code to: if valid refrl, if not ip address contact
>-		the helper that resolves tcp names, mount to it, try to 
>+		the helper that resolves tcp names, mount to it, try to
> 		tcon to it unmount it if fail */
> 
> 	kfree(referrals);
>@@ -1421,10 +1456,9 @@ connect_to_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
> }
> 
> int
>-get_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
>-			const char *old_path, const struct nls_table *nls_codepage, 
>-			unsigned int *pnum_referrals, 
>-			unsigned char ** preferrals, int remap)
>+get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
>+	     const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
>+	     unsigned char **preferrals, int remap)
> {
> 	char *temp_unc;
> 	int rc = 0;
>@@ -1433,7 +1467,8 @@ get_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
> 
> 	if (pSesInfo->ipc_tid == 0) {
> 		temp_unc = kmalloc(2 /* for slashes */ +
>-			strnlen(pSesInfo->serverName,SERVER_NAME_LEN_WITH_NULL * 2)
>+			strnlen(pSesInfo->serverName,
>+				SERVER_NAME_LEN_WITH_NULL * 2)
> 				 + 1 + 4 /* slash IPC$ */  + 2,
> 				GFP_KERNEL);
> 		if (temp_unc == NULL)
>@@ -1444,7 +1479,7 @@ get_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
> 		strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
> 		rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
> 		cFYI(1,
>-		     ("CIFS Tcon rc = %d ipc_tid = %d", rc,pSesInfo->ipc_tid));
>+		     ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
> 		kfree(temp_unc);
> 	}
> 	if (rc == 0)
>@@ -1455,37 +1490,38 @@ get_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
> }
> 
> /* See RFC1001 section 14 on representation of Netbios names */
>-static void rfc1002mangle(char * target,char * source, unsigned int length)
>+static void rfc1002mangle(char *target, char *source, unsigned int length)
> {
>-	unsigned int i,j;
>+	unsigned int i, j;
> 
>-	for(i=0,j=0;i<(length);i++) {
>+	for (i = 0, j = 0; i < (length); i++) {
> 		/* mask a nibble at a time and encode */
> 		target[j] = 'A' + (0x0F & (source[i] >> 4));
> 		target[j+1] = 'A' + (0x0F & source[i]);
>-		j+=2;
>+		j += 2;
> 	}
> 
> }
> 
> 
> static int
>-ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket, 
>-	     char * netbios_name, char * target_name)
>+ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
>+	     char *netbios_name, char *target_name)
> {
> 	int rc = 0;
> 	int connected = 0;
> 	__be16 orig_port = 0;
> 
>-	if(*csocket == NULL) {
>-		rc = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, csocket);
>+	if (*csocket == NULL) {
>+		rc = sock_create_kern(PF_INET, SOCK_STREAM,
>+				      IPPROTO_TCP, csocket);
> 		if (rc < 0) {
>-			cERROR(1, ("Error %d creating socket",rc));
>+			cERROR(1, ("Error %d creating socket", rc));
> 			*csocket = NULL;
> 			return rc;
> 		} else {
> 		/* BB other socket options to set KEEPALIVE, NODELAY? */
>-			cFYI(1,("Socket created"));
>+			cFYI(1, ("Socket created"));
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
> 			(*csocket)->sk->sk_allocation = GFP_NOFS;
> #else
>@@ -1495,26 +1531,26 @@ ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
> 	}
> 
> 	psin_server->sin_family = AF_INET;
>-	if(psin_server->sin_port) { /* user overrode default port */
>+	if (psin_server->sin_port) { /* user overrode default port */
> 		rc = (*csocket)->ops->connect(*csocket,
> 				(struct sockaddr *) psin_server,
>-				sizeof (struct sockaddr_in),0);
>+				sizeof (struct sockaddr_in), 0);
> 		if (rc >= 0)
> 			connected = 1;
>-	} 
>+	}
> 
>-	if(!connected) {
>-		/* save original port so we can retry user specified port  
>+	if (!connected) {
>+		/* save original port so we can retry user specified port
> 			later if fall back ports fail this time  */
> 		orig_port = psin_server->sin_port;
> 
> 		/* do not retry on the same port we just failed on */
>-		if(psin_server->sin_port != htons(CIFS_PORT)) {
>+		if (psin_server->sin_port != htons(CIFS_PORT)) {
> 			psin_server->sin_port = htons(CIFS_PORT);
> 
> 			rc = (*csocket)->ops->connect(*csocket,
> 					(struct sockaddr *) psin_server,
>-					sizeof (struct sockaddr_in),0);
>+					sizeof (struct sockaddr_in), 0);
> 			if (rc >= 0)
> 				connected = 1;
> 		}
>@@ -1522,32 +1558,34 @@ ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
> 	if (!connected) {
> 		psin_server->sin_port = htons(RFC1001_PORT);
> 		rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
>-					      psin_server, sizeof (struct sockaddr_in),0);
>-		if (rc >= 0) 
>+					      psin_server,
>+					      sizeof (struct sockaddr_in), 0);
>+		if (rc >= 0)
> 			connected = 1;
> 	}
> 
> 	/* give up here - unless we want to retry on different
> 		protocol families some day */
> 	if (!connected) {
>-		if(orig_port)
>+		if (orig_port)
> 			psin_server->sin_port = orig_port;
>-		cFYI(1,("Error %d connecting to server via ipv4",rc));
>+		cFYI(1, ("Error %d connecting to server via ipv4", rc));
> 		sock_release(*csocket);
> 		*csocket = NULL;
> 		return rc;
> 	}
>-	/* Eventually check for other socket options to change from 
>-		the default. sock_setsockopt not used because it expects 
>+	/* Eventually check for other socket options to change from
>+		the default. sock_setsockopt not used because it expects
> 		user space buffer */
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
>-	 cFYI(1,("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",(*csocket)->sk->sk_sndbuf,
>+	 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
>+		 (*csocket)->sk->sk_sndbuf,
> 		 (*csocket)->sk->sk_rcvbuf, (*csocket)->sk->sk_rcvtimeo));
> 	(*csocket)->sk->sk_rcvtimeo = 7 * HZ;
> 	/* make the bufsizes depend on wsize/rsize and max requests */
>-	if((*csocket)->sk->sk_sndbuf < (200 * 1024))
>+	if ((*csocket)->sk->sk_sndbuf < (200 * 1024))
> 		(*csocket)->sk->sk_sndbuf = 200 * 1024;
>-	if((*csocket)->sk->sk_rcvbuf < (140 * 1024))
>+	if ((*csocket)->sk->sk_rcvbuf < (140 * 1024))
> 		(*csocket)->sk->sk_rcvbuf = 140 * 1024;
> #else
>          cFYI(1,("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",(*csocket)->sk->sndbuf,
>@@ -1559,33 +1597,35 @@ ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
>         if((*csocket)->sk->rcvbuf < (140 * 1024))
>                 (*csocket)->sk->rcvbuf = 140 * 1024;
> #endif
>+
> 	/* send RFC1001 sessinit */
>-	if(psin_server->sin_port == htons(RFC1001_PORT)) {
>+	if (psin_server->sin_port == htons(RFC1001_PORT)) {
> 		/* some servers require RFC1001 sessinit before sending
>-		negprot - BB check reconnection in case where second 
>+		negprot - BB check reconnection in case where second
> 		sessinit is sent but no second negprot */
>-		struct rfc1002_session_packet * ses_init_buf;
>-		struct smb_hdr * smb_buf;
>-		ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet), GFP_KERNEL);
>-		if(ses_init_buf) {
>+		struct rfc1002_session_packet *ses_init_buf;
>+		struct smb_hdr *smb_buf;
>+		ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
>+				       GFP_KERNEL);
>+		if (ses_init_buf) {
> 			ses_init_buf->trailer.session_req.called_len = 32;
>-			if(target_name && (target_name[0] != 0)) {
>+			if (target_name && (target_name[0] != 0)) {
> 				rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
> 					target_name, 16);
> 			} else {
> 				rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
>-					DEFAULT_CIFS_CALLED_NAME,16);
>+					DEFAULT_CIFS_CALLED_NAME, 16);
> 			}
> 
> 			ses_init_buf->trailer.session_req.calling_len = 32;
> 			/* calling name ends in null (byte 16) from old smb
> 			convention. */
>-			if(netbios_name && (netbios_name[0] !=0)) {
>+			if (netbios_name && (netbios_name[0] != 0)) {
> 				rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
>-					netbios_name,16);
>+					netbios_name, 16);
> 			} else {
> 				rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
>-					"LINUX_CIFS_CLNT",16);
>+					"LINUX_CIFS_CLNT", 16);
> 			}
> 			ses_init_buf->trailer.session_req.scope1 = 0;
> 			ses_init_buf->trailer.session_req.scope2 = 0;
>@@ -1595,20 +1635,20 @@ ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
> 			rc = smb_send(*csocket, smb_buf, 0x44,
> 				(struct sockaddr *)psin_server);
> 			kfree(ses_init_buf);
>-			msleep(1); /* RFC1001 layer in at least one server 
>+			msleep(1); /* RFC1001 layer in at least one server
> 				      requires very short break before negprot
> 				      presumably because not expecting negprot
> 				      to follow so fast.  This is a simple
>-				      solution that works without 
>+				      solution that works without
> 				      complicating the code and causes no
> 				      significant slowing down on mount
> 				      for everyone else */
> 		}
>-		/* else the negprot may still work without this 
>+		/* else the negprot may still work without this
> 		even though malloc failed */
>-		
>+
> 	}
>-		
>+
> 	return rc;
> }
> 
>@@ -1619,15 +1659,16 @@ ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
> 	int connected = 0;
> 	__be16 orig_port = 0;
> 
>-	if(*csocket == NULL) {
>-		rc = sock_create_kern(PF_INET6, SOCK_STREAM, IPPROTO_TCP, csocket);
>+	if (*csocket == NULL) {
>+		rc = sock_create_kern(PF_INET6, SOCK_STREAM,
>+				      IPPROTO_TCP, csocket);
> 		if (rc < 0) {
>-			cERROR(1, ("Error %d creating ipv6 socket",rc));
>+			cERROR(1, ("Error %d creating ipv6 socket", rc));
> 			*csocket = NULL;
> 			return rc;
> 		} else {
> 		/* BB other socket options to set KEEPALIVE, NODELAY? */
>-			 cFYI(1,("ipv6 Socket created"));
>+			 cFYI(1, ("ipv6 Socket created"));
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
> 			(*csocket)->sk->sk_allocation = GFP_NOFS;
> #else
>@@ -1638,26 +1679,26 @@ ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
> 
> 	psin_server->sin6_family = AF_INET6;
> 
>-	if(psin_server->sin6_port) { /* user overrode default port */
>+	if (psin_server->sin6_port) { /* user overrode default port */
> 		rc = (*csocket)->ops->connect(*csocket,
> 				(struct sockaddr *) psin_server,
>-				sizeof (struct sockaddr_in6),0);
>+				sizeof (struct sockaddr_in6), 0);
> 		if (rc >= 0)
> 			connected = 1;
>-	} 
>+	}
> 
>-	if(!connected) {
>-		/* save original port so we can retry user specified port  
>+	if (!connected) {
>+		/* save original port so we can retry user specified port
> 			later if fall back ports fail this time  */
> 
> 		orig_port = psin_server->sin6_port;
> 		/* do not retry on the same port we just failed on */
>-		if(psin_server->sin6_port != htons(CIFS_PORT)) {
>+		if (psin_server->sin6_port != htons(CIFS_PORT)) {
> 			psin_server->sin6_port = htons(CIFS_PORT);
> 
> 			rc = (*csocket)->ops->connect(*csocket,
> 					(struct sockaddr *) psin_server,
>-					sizeof (struct sockaddr_in6),0);
>+					sizeof (struct sockaddr_in6), 0);
> 			if (rc >= 0)
> 				connected = 1;
> 		}
>@@ -1665,33 +1706,144 @@ ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
> 	if (!connected) {
> 		psin_server->sin6_port = htons(RFC1001_PORT);
> 		rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
>-					 psin_server, sizeof (struct sockaddr_in6),0);
>-		if (rc >= 0) 
>+				 psin_server, sizeof (struct sockaddr_in6), 0);
>+		if (rc >= 0)
> 			connected = 1;
> 	}
> 
> 	/* give up here - unless we want to retry on different
> 		protocol families some day */
> 	if (!connected) {
>-		if(orig_port)
>+		if (orig_port)
> 			psin_server->sin6_port = orig_port;
>-		cFYI(1,("Error %d connecting to server via ipv6",rc));
>+		cFYI(1, ("Error %d connecting to server via ipv6", rc));
> 		sock_release(*csocket);
> 		*csocket = NULL;
> 		return rc;
> 	}
>-	/* Eventually check for other socket options to change from 
>-		the default. sock_setsockopt not used because it expects 
>+	/* Eventually check for other socket options to change from
>+		the default. sock_setsockopt not used because it expects
> 		user space buffer */
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
> 	(*csocket)->sk->sk_rcvtimeo = 7 * HZ;
> #else
> 	(*csocket)->sk->rcvtimeo = 7 * HZ;
> #endif
>-		
>+
> 	return rc;
> }
> 
>+void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
>+			  struct super_block *sb, struct smb_vol *vol_info)
>+{
>+	/* if we are reconnecting then should we check to see if
>+	 * any requested capabilities changed locally e.g. via
>+	 * remount but we can not do much about it here
>+	 * if they have (even if we could detect it by the following)
>+	 * Perhaps we could add a backpointer to array of sb from tcon
>+	 * or if we change to make all sb to same share the same
>+	 * sb as NFS - then we only have one backpointer to sb.
>+	 * What if we wanted to mount the server share twice once with
>+	 * and once without posixacls or posix paths? */
>+	__u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
>+
>+	if (vol_info && vol_info->no_linux_ext) {
>+		tcon->fsUnixInfo.Capability = 0;
>+		tcon->unix_ext = 0; /* Unix Extensions disabled */
>+		cFYI(1, ("Linux protocol extensions disabled"));
>+		return;
>+	} else if (vol_info)
>+		tcon->unix_ext = 1; /* Unix Extensions supported */
>+
>+	if (tcon->unix_ext == 0) {
>+		cFYI(1, ("Unix extensions disabled so not set on reconnect"));
>+		return;
>+	}
>+
>+	if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
>+		__u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
>+
>+		/* check for reconnect case in which we do not
>+		   want to change the mount behavior if we can avoid it */
>+		if (vol_info == NULL) {
>+			/* turn off POSIX ACL and PATHNAMES if not set
>+			   originally at mount time */
>+			if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
>+				cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
>+			if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0)
>+				cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
>+		}
>+
>+		cap &= CIFS_UNIX_CAP_MASK;
>+		if (vol_info && vol_info->no_psx_acl)
>+			cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
>+		else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
>+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)			
>+			cFYI(1, ("negotiated posix acl support"));
>+			if (sb)
>+				sb->s_flags |= MS_POSIXACL;
>+#else
>+				cFYI(1,("ACLs not supported"));
>+#endif
>+		}
>+
>+		if (vol_info && vol_info->posix_paths == 0)
>+			cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
>+		else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
>+			cFYI(1, ("negotiate posix pathnames"));
>+			if (sb)
>+				CIFS_SB(sb)->mnt_cifs_flags |=
>+					CIFS_MOUNT_POSIX_PATHS;
>+		}
>+
>+		/* We might be setting the path sep back to a different
>+		form if we are reconnecting and the server switched its
>+		posix path capability for this share */
>+		if (sb && (CIFS_SB(sb)->prepathlen > 0))
>+			CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
>+
>+		if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
>+			if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
>+				CIFS_SB(sb)->rsize = 127 * 1024;
>+#ifdef CONFIG_CIFS_DEBUG2
>+				cFYI(1, ("larger reads not supported by srv"));
>+#endif
>+			}
>+		}
>+
>+
>+		cFYI(1, ("Negotiate caps 0x%x", (int)cap));
>+#ifdef CONFIG_CIFS_DEBUG2
>+		if (cap & CIFS_UNIX_FCNTL_CAP)
>+			cFYI(1, ("FCNTL cap"));
>+		if (cap & CIFS_UNIX_EXTATTR_CAP)
>+			cFYI(1, ("EXTATTR cap"));
>+		if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
>+			cFYI(1, ("POSIX path cap"));
>+		if (cap & CIFS_UNIX_XATTR_CAP)
>+			cFYI(1, ("XATTR cap"));
>+		if (cap & CIFS_UNIX_POSIX_ACL_CAP)
>+			cFYI(1, ("POSIX ACL cap"));
>+		if (cap & CIFS_UNIX_LARGE_READ_CAP)
>+			cFYI(1, ("very large read cap"));
>+		if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
>+			cFYI(1, ("very large write cap"));
>+#endif /* CIFS_DEBUG2 */
>+		if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
>+			if (vol_info == NULL)
>+				cFYI(1, ("resetting capabilities failed"));
>+			else
>+				cERROR(1, ("Negotiating Unix capabilities "
>+					   "with the server failed.  Consider "
>+					   "mounting with the Unix Extensions\n"
>+					   "disabled, if problems are found, "
>+					   "by specifying the nounix mount "
>+					   "option."));
>+
>+		}
>+	}
>+}
>+
> int
> cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 	   char *mount_data, const char *devname)
>@@ -1711,8 +1863,8 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 	xid = GetXid();
> 
> /* cFYI(1, ("Entering cifs_mount. Xid: %d with: %s", xid, mount_data)); */
>-	
>-	memset(&volume_info,0,sizeof(struct smb_vol));
>+
>+	memset(&volume_info, 0, sizeof(struct smb_vol));
> 	if (cifs_parse_mount_options(mount_data, devname, &volume_info)) {
> 		kfree(volume_info.UNC);
> 		kfree(volume_info.password);
>@@ -1722,16 +1874,15 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 	}
> 
> 	if (volume_info.nullauth) {
>-		cFYI(1,("null user"));
>+		cFYI(1, ("null user"));
> 		volume_info.username = NULL;
> 	} else if (volume_info.username) {
> 		/* BB fixme parse for domain name here */
>-		cFYI(1, ("Username: %s ", volume_info.username));
>-
>+		cFYI(1, ("Username: %s", volume_info.username));
> 	} else {
> 		cifserror("No username specified");
>-        /* In userspace mount helper we can get user name from alternate
>-           locations such as env variables and files on disk */
>+	/* In userspace mount helper we can get user name from alternate
>+	   locations such as env variables and files on disk */
> 		kfree(volume_info.UNC);
> 		kfree(volume_info.password);
> 		kfree(volume_info.prepath);
>@@ -1740,18 +1891,20 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 	}
> 
> 	if (volume_info.UNCip && volume_info.UNC) {
>-		rc = cifs_inet_pton(AF_INET, volume_info.UNCip,&sin_server.sin_addr.s_addr);
>+		rc = cifs_inet_pton(AF_INET, volume_info.UNCip,
>+				    &sin_server.sin_addr.s_addr);
> 
>-		if(rc <= 0) {
>+		if (rc <= 0) {
> 			/* not ipv4 address, try ipv6 */
>-			rc = cifs_inet_pton(AF_INET6,volume_info.UNCip,&sin_server6.sin6_addr.in6_u); 
>-			if(rc > 0)
>+			rc = cifs_inet_pton(AF_INET6, volume_info.UNCip,
>+					    &sin_server6.sin6_addr.in6_u);
>+			if (rc > 0)
> 				address_type = AF_INET6;
> 		} else {
> 			address_type = AF_INET;
> 		}
>-       
>-		if(rc <= 0) {
>+
>+		if (rc <= 0) {
> 			/* we failed translating address */
> 			kfree(volume_info.UNC);
> 			kfree(volume_info.password);
>@@ -1763,9 +1916,10 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 		cFYI(1, ("UNC: %s ip: %s", volume_info.UNC, volume_info.UNCip));
> 		/* success */
> 		rc = 0;
>-	} else if (volume_info.UNCip){
>-		/* BB using ip addr as server name connect to the DFS root below */
>-		cERROR(1,("Connecting to DFS root not implemented yet"));
>+	} else if (volume_info.UNCip) {
>+		/* BB using ip addr as server name to connect to the
>+		   DFS root below */
>+		cERROR(1, ("Connecting to DFS root not implemented yet"));
> 		kfree(volume_info.UNC);
> 		kfree(volume_info.password);
> 		kfree(volume_info.prepath);
>@@ -1773,7 +1927,8 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 		return -EINVAL;
> 	} else /* which servers DFS root would we conect to */ {
> 		cERROR(1,
>-		       ("CIFS mount error: No UNC path (e.g. -o unc=//192.168.1.100/public) specified"));
>+		       ("CIFS mount error: No UNC path (e.g. -o "
>+			"unc=//192.168.1.100/public) specified"));
> 		kfree(volume_info.UNC);
> 		kfree(volume_info.password);
> 		kfree(volume_info.prepath);
>@@ -1782,13 +1937,14 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 	}
> 
> 	/* this is needed for ASCII cp to Unicode converts */
>-	if(volume_info.iocharset == NULL) {
>+	if (volume_info.iocharset == NULL) {
> 		cifs_sb->local_nls = load_nls_default();
> 	/* load_nls_default can not return null */
> 	} else {
> 		cifs_sb->local_nls = load_nls(volume_info.iocharset);
>-		if(cifs_sb->local_nls == NULL) {
>-			cERROR(1,("CIFS mount error: iocharset %s not found",volume_info.iocharset));
>+		if (cifs_sb->local_nls == NULL) {
>+			cERROR(1, ("CIFS mount error: iocharset %s not found",
>+				 volume_info.iocharset));
> 			kfree(volume_info.UNC);
> 			kfree(volume_info.password);
> 			kfree(volume_info.prepath);
>@@ -1797,15 +1953,16 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 		}
> 	}
> 
>-	if(address_type == AF_INET)
>+	if (address_type == AF_INET)
> 		existingCifsSes = cifs_find_tcp_session(&sin_server.sin_addr,
> 			NULL /* no ipv6 addr */,
> 			volume_info.username, &srvTcp);
>-	else if(address_type == AF_INET6)
>+	else if (address_type == AF_INET6) {
>+		cFYI(1, ("looking for ipv6 address"));
> 		existingCifsSes = cifs_find_tcp_session(NULL /* no ipv4 addr */,
> 			&sin_server6.sin6_addr,
> 			volume_info.username, &srvTcp);
>-	else {
>+	} else {
> 		kfree(volume_info.UNC);
> 		kfree(volume_info.password);
> 		kfree(volume_info.prepath);
>@@ -1813,21 +1970,26 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 		return -EINVAL;
> 	}
> 
>-
> 	if (srvTcp) {
>-		cFYI(1, ("Existing tcp session with server found"));                
>+		cFYI(1, ("Existing tcp session with server found"));
> 	} else {	/* create socket */
>-		if(volume_info.port)
>+		if (volume_info.port)
> 			sin_server.sin_port = htons(volume_info.port);
> 		else
> 			sin_server.sin_port = 0;
>-		rc = ipv4_connect(&sin_server,&csocket,
>+		if (address_type == AF_INET6) {
>+			cFYI(1, ("attempting ipv6 connect"));
>+			/* BB should we allow ipv6 on port 139? */
>+			/* other OS never observed in Wild doing 139 with v6 */
>+			rc = ipv6_connect(&sin_server6, &csocket);
>+		} else
>+			rc = ipv4_connect(&sin_server, &csocket,
> 				  volume_info.source_rfc1001_name,
> 				  volume_info.target_rfc1001_name);
> 		if (rc < 0) {
>-			cERROR(1,
>-			       ("Error connecting to IPv4 socket. Aborting operation"));
>-			if(csocket != NULL)
>+			cERROR(1, ("Error connecting to IPv4 socket. "
>+				   "Aborting operation"));
>+			if (csocket != NULL)
> 				sock_release(csocket);
> 			kfree(volume_info.UNC);
> 			kfree(volume_info.password);
>@@ -1847,8 +2009,9 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 			return rc;
> 		} else {
> 			memset(srvTcp, 0, sizeof (struct TCP_Server_Info));
>-			memcpy(&srvTcp->addr.sockAddr, &sin_server, sizeof (struct sockaddr_in));
>-			atomic_set(&srvTcp->inFlight,0);
>+			memcpy(&srvTcp->addr.sockAddr, &sin_server,
>+				sizeof (struct sockaddr_in));
>+			atomic_set(&srvTcp->inFlight, 0);
> 			/* BB Add code for ipv6 case too */
> 			srvTcp->ssocket = csocket;
> 			srvTcp->protocolType = IPV4;
>@@ -1860,10 +2023,11 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 			so no need to spinlock this init of tcpStatus */
> 			srvTcp->tcpStatus = CifsNew;
> 			init_MUTEX(&srvTcp->tcpSem);
>-			rc = (int)kernel_thread((void *)(void *)cifs_demultiplex_thread, srvTcp,
>-				      CLONE_FS | CLONE_FILES | CLONE_VM);
>-			if(rc < 0) {
>-				rc = -ENOMEM;
>+			srvTcp->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread, srvTcp, "cifsd");
>+			if ( IS_ERR(srvTcp->tsk) ) {
>+				rc = PTR_ERR(srvTcp->tsk);
>+				cERROR(1, ("error %d create cifsd thread", rc));
>+				srvTcp->tsk = NULL;
> 				sock_release(csocket);
> 				kfree(volume_info.UNC);
> 				kfree(volume_info.password);
>@@ -1873,8 +2037,10 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 			}
> 			wait_for_completion(&cifsd_complete);
> 			rc = 0;
>-			memcpy(srvTcp->workstation_RFC1001_name, volume_info.source_rfc1001_name,16);
>-			memcpy(srvTcp->server_RFC1001_name, volume_info.target_rfc1001_name,16);
>+			memcpy(srvTcp->workstation_RFC1001_name,
>+				volume_info.source_rfc1001_name, 16);
>+			memcpy(srvTcp->server_RFC1001_name,
>+				volume_info.target_rfc1001_name, 16);
> 			srvTcp->sequence_number = 0;
> 		}
> 	}
>@@ -1895,18 +2061,19 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 				NIPQUAD(sin_server.sin_addr.s_addr));
> 		}
> 
>-		if (!rc){
>-			/* volume_info.password freed at unmount */   
>+		if (!rc) {
>+			/* volume_info.password freed at unmount */
> 			if (volume_info.password)
> 				pSesInfo->password = volume_info.password;
> 			if (volume_info.username)
> 				strncpy(pSesInfo->userName,
>-					volume_info.username,MAX_USERNAME_SIZE);
>+					volume_info.username,
>+					MAX_USERNAME_SIZE);
> 			if (volume_info.domainname) {
> 				int len = strlen(volume_info.domainname);
>-				pSesInfo->domainName = 
>+				pSesInfo->domainName =
> 					kmalloc(len + 1, GFP_KERNEL);
>-				if(pSesInfo->domainName)
>+				if (pSesInfo->domainName)
> 					strcpy(pSesInfo->domainName,
> 						volume_info.domainname);
> 			}
>@@ -1914,81 +2081,86 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 			pSesInfo->overrideSecFlg = volume_info.secFlg;
> 			down(&pSesInfo->sesSem);
> 			/* BB FIXME need to pass vol->secFlgs BB */
>-			rc = cifs_setup_session(xid,pSesInfo, cifs_sb->local_nls);
>+			rc = cifs_setup_session(xid, pSesInfo,
>+						cifs_sb->local_nls);
> 			up(&pSesInfo->sesSem);
>-			if(!rc)
>+			if (!rc)
> 				atomic_inc(&srvTcp->socketUseCount);
> 		} else
> 			kfree(volume_info.password);
> 	}
>-    
>+
> 	/* search for existing tcon to this server share */
> 	if (!rc) {
>-		if(volume_info.rsize > CIFSMaxBufSize) {
>-			cERROR(1,("rsize %d too large, using MaxBufSize",
>+		if (volume_info.rsize > CIFSMaxBufSize) {
>+			cERROR(1, ("rsize %d too large, using MaxBufSize",
> 				volume_info.rsize));
> 			cifs_sb->rsize = CIFSMaxBufSize;
>-		} else if((volume_info.rsize) && (volume_info.rsize <= CIFSMaxBufSize))
>+		} else if ((volume_info.rsize) &&
>+				(volume_info.rsize <= CIFSMaxBufSize))
> 			cifs_sb->rsize = volume_info.rsize;
> 		else /* default */
> 			cifs_sb->rsize = CIFSMaxBufSize;
> 
>-		if(volume_info.wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
>-			cERROR(1,("wsize %d too large using 4096 instead",
>+		if (volume_info.wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
>+			cERROR(1, ("wsize %d too large, using 4096 instead",
> 				  volume_info.wsize));
> 			cifs_sb->wsize = 4096;
>-		} else if(volume_info.wsize)
>+		} else if (volume_info.wsize)
> 			cifs_sb->wsize = volume_info.wsize;
> 		else
>-			cifs_sb->wsize = 
>+			cifs_sb->wsize =
> 				min_t(const int, PAGEVEC_SIZE * PAGE_CACHE_SIZE,
> 					127*1024);
> 			/* old default of CIFSMaxBufSize was too small now
>-			   that SMB Write2 can send multiple pages in kvec.   
>+			   that SMB Write2 can send multiple pages in kvec.
> 			   RFC1001 does not describe what happens when frame
> 			   bigger than 128K is sent so use that as max in
> 			   conjunction with 52K kvec constraint on arch with 4K
> 			   page size  */
> 
>-		if(cifs_sb->rsize < 2048) {
>-			cifs_sb->rsize = 2048; 
>+		if (cifs_sb->rsize < 2048) {
>+			cifs_sb->rsize = 2048;
> 			/* Windows ME may prefer this */
>-			cFYI(1,("readsize set to minimum 2048"));
>+			cFYI(1, ("readsize set to minimum: 2048"));
> 		}
> 		/* calculate prepath */
> 		cifs_sb->prepath = volume_info.prepath;
>-		if(cifs_sb->prepath) {
>+		if (cifs_sb->prepath) {
> 			cifs_sb->prepathlen = strlen(cifs_sb->prepath);
> 			cifs_sb->prepath[0] = CIFS_DIR_SEP(cifs_sb);
> 			volume_info.prepath = NULL;
>-		} else 
>+		} else
> 			cifs_sb->prepathlen = 0;
> 		cifs_sb->mnt_uid = volume_info.linux_uid;
> 		cifs_sb->mnt_gid = volume_info.linux_gid;
> 		cifs_sb->mnt_file_mode = volume_info.file_mode;
> 		cifs_sb->mnt_dir_mode = volume_info.dir_mode;
>-		cFYI(1,("file mode: 0x%x  dir mode: 0x%x",
>-			cifs_sb->mnt_file_mode,cifs_sb->mnt_dir_mode));
>+		cFYI(1, ("file mode: 0x%x  dir mode: 0x%x",
>+			cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
> 
>-		if(volume_info.noperm)
>+		if (volume_info.noperm)
> 			cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
>-		if(volume_info.setuids)
>+		if (volume_info.setuids)
> 			cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
>-		if(volume_info.server_ino)
>+		if (volume_info.server_ino)
> 			cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
>-		if(volume_info.remap)
>+		if (volume_info.remap)
> 			cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
>-		if(volume_info.no_xattr)
>+		if (volume_info.no_xattr)
> 			cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
>-		if(volume_info.sfu_emul)
>+		if (volume_info.sfu_emul)
> 			cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
>-		if(volume_info.nobrl)
>+		if (volume_info.nobrl)
> 			cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
>-		if(volume_info.cifs_acl)
>+		if (volume_info.cifs_acl)
> 			cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
>-
>-		if(volume_info.direct_io) {
>-			cFYI(1,("mounting share using direct i/o"));
>+		if (volume_info.override_uid)
>+			cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
>+		if (volume_info.override_gid)
>+			cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
>+		if (volume_info.direct_io) {
>+			cFYI(1, ("mounting share using direct i/o"));
> 			cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
> 		}
> 
>@@ -1999,7 +2171,7 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 			cFYI(1, ("Found match on UNC path"));
> 			/* we can have only one retry value for a connection
> 			   to a share so for resources mounted more than once
>-			   to the same server share the last value passed in 
>+			   to the same server share the last value passed in
> 			   for the retry flag is used */
> 			tcon->retry = volume_info.retry;
> 			tcon->nocase = volume_info.nocase;
>@@ -2008,21 +2180,26 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 			if (tcon == NULL)
> 				rc = -ENOMEM;
> 			else {
>-				/* check for null share name ie connect to dfs root */
>+				/* check for null share name ie connecting to
>+				 * dfs root */
> 
>-				/* BB check if this works for exactly length three strings */
>+				/* BB check if this works for exactly length
>+				 * three strings */
> 				if ((strchr(volume_info.UNC + 3, '\\') == NULL)
> 				    && (strchr(volume_info.UNC + 3, '/') ==
> 					NULL)) {
> 					rc = connect_to_dfs_path(xid, pSesInfo,
>-							"", cifs_sb->local_nls,
>-							cifs_sb->mnt_cifs_flags & 
>-							  CIFS_MOUNT_MAP_SPECIAL_CHR);
>+						"", cifs_sb->local_nls,
>+						cifs_sb->mnt_cifs_flags &
>+						  CIFS_MOUNT_MAP_SPECIAL_CHR);
> 					kfree(volume_info.UNC);
> 					FreeXid(xid);
> 					return -ENODEV;
> 				} else {
>-					rc = CIFSTCon(xid, pSesInfo, 
>+					/* BB Do we need to wrap sesSem around
>+					 * this TCon call and Unix SetFS as
>+					 * we do on SessSetup and reconnect? */
>+					rc = CIFSTCon(xid, pSesInfo,
> 						volume_info.UNC,
> 						tcon, cifs_sb->local_nls);
> 					cFYI(1, ("CIFS Tcon rc = %d", rc));
>@@ -2035,13 +2212,15 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 			}
> 		}
> 	}
>-	if(pSesInfo) {
>+	if (pSesInfo) {
> 		if (pSesInfo->capabilities & CAP_LARGE_FILES) {
> 			sb->s_maxbytes = (u64) 1 << 63;
> 		} else
> 			sb->s_maxbytes = (u64) 1 << 31;	/* 2 GB */
> 	}
>+
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 10)
>+	/* BB FIXME fix time_gran to be larger for LANMAN sessions */
> 	sb->s_time_gran = 100;
> #endif
> 
>@@ -2049,13 +2228,20 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 	if (rc) {
> 		/* if session setup failed, use count is zero but
> 		we still need to free cifsd thread */
>-		if(atomic_read(&srvTcp->socketUseCount) == 0) {
>+		if (atomic_read(&srvTcp->socketUseCount) == 0) {
> 			spin_lock(&GlobalMid_Lock);
> 			srvTcp->tcpStatus = CifsExiting;
> 			spin_unlock(&GlobalMid_Lock);
>-			if(srvTcp->tsk) {
>-				force_sig(SIGKILL,srvTcp->tsk);
>-				wait_for_completion(&cifsd_complete);
>+			if (srvTcp->tsk) {
>+				struct task_struct *tsk;
>+				/* If we could verify that kthread_stop would
>+				   always wake up processes blocked in
>+				   tcp in recv_mesg then we could remove the
>+				   send_sig call */
>+				force_sig(SIGKILL, srvTcp->tsk);
>+				tsk = srvTcp->tsk;
>+				if (tsk)
>+					kthread_stop(tsk);
> 			}
> 		}
> 		 /* If find_unc succeeded then rc == 0 so we can not end */
>@@ -2063,15 +2249,20 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 			tconInfoFree(tcon);
> 		if (existingCifsSes == NULL) {
> 			if (pSesInfo) {
>-				if ((pSesInfo->server) && 
>+				if ((pSesInfo->server) &&
> 				    (pSesInfo->status == CifsGood)) {
> 					int temp_rc;
> 					temp_rc = CIFSSMBLogoff(xid, pSesInfo);
> 					/* if the socketUseCount is now zero */
>-					if((temp_rc == -ESHUTDOWN) &&
>-					   (pSesInfo->server->tsk)) {
>-						force_sig(SIGKILL,pSesInfo->server->tsk);
>-						wait_for_completion(&cifsd_complete);
>+					if ((temp_rc == -ESHUTDOWN) &&
>+					    (pSesInfo->server) &&
>+					    (pSesInfo->server->tsk)) {
>+						struct task_struct *tsk;
>+						force_sig(SIGKILL,
>+							pSesInfo->server->tsk);
>+						tsk = pSesInfo->server->tsk;
>+						if (tsk)
>+							kthread_stop(tsk);
> 					}
> 				} else
> 					cFYI(1, ("No session or bad tcon"));
>@@ -2088,56 +2279,28 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
> 		CIFSSMBQFSDeviceInfo(xid, tcon);
> 		CIFSSMBQFSAttributeInfo(xid, tcon);
> 
>-		if (tcon->ses->capabilities & CAP_UNIX) {
>-			if(!CIFSSMBQFSUnixInfo(xid, tcon)) {
>-				__u64 cap = 
>-				       le64_to_cpu(tcon->fsUnixInfo.Capability);
>-				cap &= CIFS_UNIX_CAP_MASK;
>-				if(volume_info.no_psx_acl)
>-					cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
>-				else if(CIFS_UNIX_POSIX_ACL_CAP & cap) {
>-#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
>-					cFYI(1,("negotiated posix acl support"));
>-					sb->s_flags |= MS_POSIXACL;
>-#else
>-					cFYI(1,("ACLs not supported"));
>-#endif
>-				}
>+		/* tell server which Unix caps we support */
>+		if (tcon->ses->capabilities & CAP_UNIX)
>+			/* reset of caps checks mount to see if unix extensions
>+			   disabled for just this mount */
>+			reset_cifs_unix_caps(xid, tcon, sb, &volume_info);
>+		else
>+			tcon->unix_ext = 0; /* server does not support them */
> 
>-				if(volume_info.posix_paths == 0)
>-					cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
>-				else if(cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
>-					cFYI(1,("negotiate posix pathnames"));
>-					cifs_sb->mnt_cifs_flags |= 
>-						CIFS_MOUNT_POSIX_PATHS;
>-				}
>-					
>-				cFYI(1,("Negotiate caps 0x%x",(int)cap));
>+		if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
>+			cifs_sb->rsize = 1024 * 127;
> #ifdef CONFIG_CIFS_DEBUG2
>-				if(cap & CIFS_UNIX_FCNTL_CAP)
>-					cFYI(1,("FCNTL cap"));
>-				if(cap & CIFS_UNIX_EXTATTR_CAP)
>-					cFYI(1,("EXTATTR cap"));
>-				if(cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
>-					cFYI(1,("POSIX path cap"));
>-				if(cap & CIFS_UNIX_XATTR_CAP)
>-					cFYI(1,("XATTR cap"));
>-				if(cap & CIFS_UNIX_POSIX_ACL_CAP)
>-					cFYI(1,("POSIX ACL cap"));
>-#endif /* CIFS_DEBUG2 */
>-				if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
>-					cFYI(1,("setting capabilities failed"));
>-				}
>-			}
>+			cFYI(1, ("no very large read support, rsize now 127K"));
>+#endif
> 		}
> 		if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
> 			cifs_sb->wsize = min(cifs_sb->wsize,
> 					     (tcon->ses->server->maxBuf -
> 					      MAX_CIFS_HDR_SIZE));
> 		if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
>-                        cifs_sb->rsize = min(cifs_sb->rsize,
>-                                             (tcon->ses->server->maxBuf -
>-                                              MAX_CIFS_HDR_SIZE));
>+			cifs_sb->rsize = min(cifs_sb->rsize,
>+					     (tcon->ses->server->maxBuf -
>+					      MAX_CIFS_HDR_SIZE));
> 	}
> 
> 	/* volume_info.password is freed above when existing session found
>@@ -2170,7 +2333,7 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 	__u16 count;
> 
> 	cFYI(1, ("In sesssetup"));
>-	if(ses == NULL)
>+	if (ses == NULL)
> 		return -EINVAL;
> 	user = ses->userName;
> 	domain = ses->domainName;
>@@ -2190,7 +2353,8 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 	pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
> 	pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
> 
>-	if(ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
>+	if (ses->server->secMode &
>+			(SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
> 		smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
> 
> 	capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
>@@ -2209,7 +2373,7 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 	}
> 	pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
> 
>-	pSMB->req_no_secext.CaseInsensitivePasswordLength = 
>+	pSMB->req_no_secext.CaseInsensitivePasswordLength =
> 		cpu_to_le16(CIFS_SESS_KEY_SIZE);
> 
> 	pSMB->req_no_secext.CaseSensitivePasswordLength =
>@@ -2225,11 +2389,11 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 			*bcc_ptr = 0;
> 			bcc_ptr++;
> 		}
>-		if(user == NULL)
>+		if (user == NULL)
> 			bytes_returned = 0; /* skip null user */
>-	        else
>+		else
> 			bytes_returned =
>-			        cifs_strtoUCS((__le16 *) bcc_ptr, user, 100,
>+				cifs_strtoUCS((__le16 *) bcc_ptr, user, 100,
> 					nls_codepage);
> 		/* convert number of 16 bit words to bytes */
> 		bcc_ptr += 2 * bytes_returned;
>@@ -2250,12 +2414,11 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 		bcc_ptr += 2 * bytes_returned;
> 		bytes_returned =
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 18)
>-			cifs_strtoUCS((__le16 *)bcc_ptr, utsname()->release,
>-                                  32, nls_codepage);
>-
>+			cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release,
>+					32, nls_codepage);
> #else
> 			cifs_strtoUCS((__le16 *)bcc_ptr, system_utsname.release,
>-				  32, nls_codepage);
>+					32, nls_codepage);
> #endif
> 		bcc_ptr += 2 * bytes_returned;
> 		bcc_ptr += 2;
>@@ -2265,7 +2428,7 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 		bcc_ptr += 2 * bytes_returned;
> 		bcc_ptr += 2;
> 	} else {
>-		if(user != NULL) {                
>+		if (user != NULL) {
> 		    strncpy(bcc_ptr, user, 200);
> 		    bcc_ptr += strnlen(user, 200);
> 		}
>@@ -2283,8 +2446,8 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 		strcpy(bcc_ptr, "Linux version ");
> 		bcc_ptr += strlen("Linux version ");
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 18)
>-                strcpy(bcc_ptr, utsname()->release);
>-                bcc_ptr += strlen(utsname()->release) + 1;
>+		strcpy(bcc_ptr, utsname()->release);
>+		bcc_ptr += strlen(utsname()->release) + 1;
> #else
> 		strcpy(bcc_ptr, system_utsname.release);
> 		bcc_ptr += strlen(system_utsname.release) + 1;
>@@ -2305,11 +2468,12 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 		__u16 action = le16_to_cpu(pSMBr->resp.Action);
> 		__u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
> 		if (action & GUEST_LOGIN)
>-			cFYI(1, (" Guest login"));	/* do we want to mark SesInfo struct ? */
>-		ses->Suid = smb_buffer_response->Uid;	/* UID left in wire format (le) */
>+			cFYI(1, (" Guest login")); /* BB mark SesInfo struct? */
>+		ses->Suid = smb_buffer_response->Uid; /* UID left in wire format
>+							 (little endian) */
> 		cFYI(1, ("UID = %d ", ses->Suid));
>-         /* response can have either 3 or 4 word count - Samba sends 3 */
>-		bcc_ptr = pByteArea(smb_buffer_response);	
>+	/* response can have either 3 or 4 word count - Samba sends 3 */
>+		bcc_ptr = pByteArea(smb_buffer_response);
> 		if ((pSMBr->resp.hdr.WordCount == 3)
> 		    || ((pSMBr->resp.hdr.WordCount == 4)
> 			&& (blob_len < pSMBr->resp.ByteCount))) {
>@@ -2319,8 +2483,10 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 			if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
> 				if ((long) (bcc_ptr) % 2) {
> 					remaining_words =
>-					    (BCC(smb_buffer_response) - 1) /2;
>-					bcc_ptr++;	/* Unicode strings must be word aligned */
>+					    (BCC(smb_buffer_response) - 1) / 2;
>+					/* Unicode strings must be word
>+					   aligned */
>+					bcc_ptr++;
> 				} else {
> 					remaining_words =
> 						BCC(smb_buffer_response) / 2;
>@@ -2331,13 +2497,15 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> /* We look for obvious messed up bcc or strings in response so we do not go off
>    the end since (at least) WIN2K and Windows XP have a major bug in not null
>    terminating last Unicode string in response  */
>-				if(ses->serverOS)
>+				if (ses->serverOS)
> 					kfree(ses->serverOS);
>-				ses->serverOS = kzalloc(2 * (len + 1), GFP_KERNEL);
>-				if(ses->serverOS == NULL)
>+				ses->serverOS = kzalloc(2 * (len + 1),
>+							GFP_KERNEL);
>+				if (ses->serverOS == NULL)
> 					goto sesssetup_nomem;
> 				cifs_strfromUCS_le(ses->serverOS,
>-					   (__le16 *)bcc_ptr, len,nls_codepage);
>+						   (__le16 *)bcc_ptr,
>+						   len, nls_codepage);
> 				bcc_ptr += 2 * (len + 1);
> 				remaining_words -= len + 1;
> 				ses->serverOS[2 * len] = 0;
>@@ -2346,42 +2514,49 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 					len = UniStrnlen((wchar_t *)bcc_ptr,
> 							 remaining_words-1);
> 					kfree(ses->serverNOS);
>-					ses->serverNOS = kzalloc(2 * (len + 1),GFP_KERNEL);
>-					if(ses->serverNOS == NULL)
>+					ses->serverNOS = kzalloc(2 * (len + 1),
>+								 GFP_KERNEL);
>+					if (ses->serverNOS == NULL)
> 						goto sesssetup_nomem;
> 					cifs_strfromUCS_le(ses->serverNOS,
>-							   (__le16 *)bcc_ptr,len,nls_codepage);
>+							   (__le16 *)bcc_ptr,
>+							   len, nls_codepage);
> 					bcc_ptr += 2 * (len + 1);
> 					ses->serverNOS[2 * len] = 0;
> 					ses->serverNOS[1 + (2 * len)] = 0;
>-					if(strncmp(ses->serverNOS,
>-						"NT LAN Manager 4",16) == 0) {
>-						cFYI(1,("NT4 server"));
>+					if (strncmp(ses->serverNOS,
>+						"NT LAN Manager 4", 16) == 0) {
>+						cFYI(1, ("NT4 server"));
> 						ses->flags |= CIFS_SES_NT4;
> 					}
> 					remaining_words -= len + 1;
> 					if (remaining_words > 0) {
> 						len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
>-          /* last string is not always null terminated (for e.g. for Windows XP & 2000) */
>-						if(ses->serverDomain)
>+				/* last string is not always null terminated
>+				   (for e.g. for Windows XP & 2000) */
>+						if (ses->serverDomain)
> 							kfree(ses->serverDomain);
> 						ses->serverDomain =
>-						    kzalloc(2*(len+1),GFP_KERNEL);
>-						if(ses->serverDomain == NULL)
>+						    kzalloc(2*(len+1),
>+							    GFP_KERNEL);
>+						if (ses->serverDomain == NULL)
> 							goto sesssetup_nomem;
> 						cifs_strfromUCS_le(ses->serverDomain,
>-						     (__le16 *)bcc_ptr,len,nls_codepage);
>+							(__le16 *)bcc_ptr,
>+							len, nls_codepage);
> 						bcc_ptr += 2 * (len + 1);
> 						ses->serverDomain[2*len] = 0;
> 						ses->serverDomain[1+(2*len)] = 0;
>-					} /* else no more room so create dummy domain string */
>-					else {
>-						if(ses->serverDomain)
>+					} else { /* else no more room so create
>+						  dummy domain string */
>+						if (ses->serverDomain)
> 							kfree(ses->serverDomain);
>-						ses->serverDomain = 
>+						ses->serverDomain =
> 							kzalloc(2, GFP_KERNEL);
> 					}
>-				} else {	/* no room so create dummy domain and NOS string */
>+				} else { /* no room so create dummy domain
>+					    and NOS string */
>+
> 					/* if these kcallocs fail not much we
> 					   can do, but better to not fail the
> 					   sesssetup itself */
>@@ -2398,19 +2573,22 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 				    pByteArea(smb_buffer_response)
> 					    <= BCC(smb_buffer_response)) {
> 					kfree(ses->serverOS);
>-					ses->serverOS = kzalloc(len + 1,GFP_KERNEL);
>-					if(ses->serverOS == NULL)
>+					ses->serverOS = kzalloc(len + 1,
>+								GFP_KERNEL);
>+					if (ses->serverOS == NULL)
> 						goto sesssetup_nomem;
>-					strncpy(ses->serverOS,bcc_ptr, len);
>+					strncpy(ses->serverOS, bcc_ptr, len);
> 
> 					bcc_ptr += len;
>-					bcc_ptr[0] = 0;	/* null terminate the string */
>+					/* null terminate the string */
>+					bcc_ptr[0] = 0;
> 					bcc_ptr++;
> 
> 					len = strnlen(bcc_ptr, 1024);
> 					kfree(ses->serverNOS);
>-					ses->serverNOS = kzalloc(len + 1,GFP_KERNEL);
>-					if(ses->serverNOS == NULL)
>+					ses->serverNOS = kzalloc(len + 1,
>+								 GFP_KERNEL);
>+					if (ses->serverNOS == NULL)
> 						goto sesssetup_nomem;
> 					strncpy(ses->serverNOS, bcc_ptr, len);
> 					bcc_ptr += len;
>@@ -2418,23 +2596,27 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 					bcc_ptr++;
> 
> 					len = strnlen(bcc_ptr, 1024);
>-					if(ses->serverDomain)
>+					if (ses->serverDomain)
> 						kfree(ses->serverDomain);
>-					ses->serverDomain = kzalloc(len + 1,GFP_KERNEL);
>-					if(ses->serverDomain == NULL)
>+					ses->serverDomain = kzalloc(len + 1,
>+								    GFP_KERNEL);
>+					if (ses->serverDomain == NULL)
> 						goto sesssetup_nomem;
>-					strncpy(ses->serverDomain, bcc_ptr, len);
>+					strncpy(ses->serverDomain, bcc_ptr,
>+						len);
> 					bcc_ptr += len;
> 					bcc_ptr[0] = 0;
> 					bcc_ptr++;
> 				} else
> 					cFYI(1,
>-					     ("Variable field of length %d extends beyond end of smb ",
>+					     ("Variable field of length %d "
>+						"extends beyond end of smb ",
> 					      len));
> 			}
> 		} else {
> 			cERROR(1,
>-			       (" Security Blob Length extends beyond end of SMB"));
>+			       (" Security Blob Length extends beyond "
>+				"end of SMB"));
> 		}
> 	} else {
> 		cERROR(1,
>@@ -2453,7 +2635,7 @@ sesssetup_nomem:	/* do not return an error on nomem for the info strings,
> 
> static int
> CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
>-			      struct cifsSesInfo *ses, int * pNTLMv2_flag,
>+			      struct cifsSesInfo *ses, int *pNTLMv2_flag,
> 			      const struct nls_table *nls_codepage)
> {
> 	struct smb_hdr *smb_buffer;
>@@ -2473,7 +2655,7 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
> 	__u16 count;
> 
> 	cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
>-	if(ses == NULL)
>+	if (ses == NULL)
> 		return -EINVAL;
> 	domain = ses->domainName;
> 	*pNTLMv2_flag = FALSE;
>@@ -2497,7 +2679,7 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
> 	pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
> 	pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
> 
>-	if(ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
>+	if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
> 		smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
> 
> 	capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
>@@ -2525,9 +2707,9 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
> 	    NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
> 	    NTLMSSP_NEGOTIATE_56 |
> 	    /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
>-	if(sign_CIFS_PDUs)
>+	if (sign_CIFS_PDUs)
> 		negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
>-/*	if(ntlmv2_support)
>+/*	if (ntlmv2_support)
> 		negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
> 	/* setup pointers to domain name and workstation name */
> 	bcc_ptr += SecurityBlobLength;
>@@ -2553,12 +2735,11 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
> 		bcc_ptr += 2 * bytes_returned;
> 		bytes_returned =
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 18)
>-		    cifs_strtoUCS((__le16 *)bcc_ptr, utsname()->release, 32,
>-				nls_codepage);
>-
>+		    cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
>+				  nls_codepage);
> #else
> 		    cifs_strtoUCS((__le16 *)bcc_ptr, system_utsname.release, 32,
>-				nls_codepage);
>+				  nls_codepage);
> #endif
> 		bcc_ptr += 2 * bytes_returned;
> 		bcc_ptr += 2;	/* null terminate Linux version */
>@@ -2608,11 +2789,11 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
> 		__u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
> 
> 		if (action & GUEST_LOGIN)
>-			cFYI(1, (" Guest login"));	
>-        /* Do we want to set anything in SesInfo struct when guest login? */
>+			cFYI(1, (" Guest login"));
>+	/* Do we want to set anything in SesInfo struct when guest login? */
> 
>-		bcc_ptr = pByteArea(smb_buffer_response);	
>-        /* response can have either 3 or 4 word count - Samba sends 3 */
>+		bcc_ptr = pByteArea(smb_buffer_response);
>+	/* response can have either 3 or 4 word count - Samba sends 3 */
> 
> 		SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
> 		if (SecurityBlob2->MessageType != NtLmChallenge) {
>@@ -2620,7 +2801,7 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
> 			     ("Unexpected NTLMSSP message type received %d",
> 			      SecurityBlob2->MessageType));
> 		} else if (ses) {
>-			ses->Suid = smb_buffer_response->Uid; /* UID left in le format */ 
>+			ses->Suid = smb_buffer_response->Uid; /* UID left in le format */
> 			cFYI(1, ("UID = %d", ses->Suid));
> 			if ((pSMBr->resp.hdr.WordCount == 3)
> 			    || ((pSMBr->resp.hdr.WordCount == 4)
>@@ -2638,18 +2819,18 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
> 				memcpy(ses->server->cryptKey,
> 				       SecurityBlob2->Challenge,
> 				       CIFS_CRYPTO_KEY_SIZE);
>-				if(SecurityBlob2->NegotiateFlags & 
>+				if (SecurityBlob2->NegotiateFlags &
> 					cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
> 					*pNTLMv2_flag = TRUE;
> 
>-				if((SecurityBlob2->NegotiateFlags & 
>-					cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN)) 
>+				if ((SecurityBlob2->NegotiateFlags &
>+					cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
> 					|| (sign_CIFS_PDUs > 1))
>-						ses->server->secMode |= 
>-							SECMODE_SIGN_REQUIRED;	
>-				if ((SecurityBlob2->NegotiateFlags & 
>+						ses->server->secMode |=
>+							SECMODE_SIGN_REQUIRED;
>+				if ((SecurityBlob2->NegotiateFlags &
> 					cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN)) && (sign_CIFS_PDUs))
>-						ses->server->secMode |= 
>+						ses->server->secMode |=
> 							SECMODE_SIGN_ENABLED;
> 
> 				if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
>@@ -2657,7 +2838,8 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
> 						remaining_words =
> 						    (BCC(smb_buffer_response)
> 						     - 1) / 2;
>-						bcc_ptr++;	/* Unicode strings must be word aligned */
>+					 /* Must word align unicode strings */
>+						bcc_ptr++;
> 					} else {
> 						remaining_words =
> 						    BCC
>@@ -2669,7 +2851,7 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
> /* We look for obvious messed up bcc or strings in response so we do not go off
>    the end since (at least) WIN2K and Windows XP have a major bug in not null
>    terminating last Unicode string in response  */
>-					if(ses->serverOS)
>+					if (ses->serverOS)
> 						kfree(ses->serverOS);
> 					ses->serverOS =
> 					    kzalloc(2 * (len + 1), GFP_KERNEL);
>@@ -2702,8 +2884,9 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
> 							       (2 * len)] = 0;
> 						remaining_words -= len + 1;
> 						if (remaining_words > 0) {
>-							len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);	
>-           /* last string is not always null terminated (for e.g. for Windows XP & 2000) */
>+							len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
>+				/* last string not always null terminated
>+				   (for e.g. for Windows XP & 2000) */
> 							kfree(ses->serverDomain);
> 							ses->serverDomain =
> 							    kzalloc(2 *
>@@ -2741,7 +2924,7 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
> 					if (((long) bcc_ptr + len) - (long)
> 					    pByteArea(smb_buffer_response)
> 					    <= BCC(smb_buffer_response)) {
>-						if(ses->serverOS)
>+						if (ses->serverOS)
> 							kfree(ses->serverOS);
> 						ses->serverOS =
> 						    kzalloc(len + 1,
>@@ -2768,18 +2951,20 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
> 						ses->serverDomain =
> 						    kzalloc(len + 1,
> 							    GFP_KERNEL);
>-						strncpy(ses->serverDomain, bcc_ptr, len);	
>+						strncpy(ses->serverDomain,
>+							bcc_ptr, len);
> 						bcc_ptr += len;
> 						bcc_ptr[0] = 0;
> 						bcc_ptr++;
> 					} else
> 						cFYI(1,
>-						     ("Variable field of length %d extends beyond end of smb",
>+						     ("field of length %d "
>+						    "extends beyond end of smb",
> 						      len));
> 				}
> 			} else {
>-				cERROR(1,
>-				       (" Security Blob Length extends beyond end of SMB"));
>+				cERROR(1, ("Security Blob Length extends beyond"
>+					   " end of SMB"));
> 			}
> 		} else {
> 			cERROR(1, ("No session structure passed in."));
>@@ -2818,7 +3003,7 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 	__u16 count;
> 
> 	cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
>-	if(ses == NULL)
>+	if (ses == NULL)
> 		return -EINVAL;
> 	user = ses->userName;
> 	domain = ses->domainName;
>@@ -2843,7 +3028,7 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 
> 	pSMB->req.hdr.Uid = ses->Suid;
> 
>-	if(ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
>+	if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
> 		smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
> 
> 	capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
>@@ -2867,13 +3052,13 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 	strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
> 	SecurityBlob->MessageType = NtLmAuthenticate;
> 	bcc_ptr += SecurityBlobLength;
>-	negotiate_flags = 
>+	negotiate_flags =
> 	    NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
> 	    NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
> 	    0x80000000 | NTLMSSP_NEGOTIATE_128;
>-	if(sign_CIFS_PDUs)
>+	if (sign_CIFS_PDUs)
> 		negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
>-	if(ntlmv2_flag)
>+	if (ntlmv2_flag)
> 		negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
> 
> /* setup pointers to domain name and workstation name */
>@@ -2905,45 +3090,45 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 			SecurityBlob->DomainName.Length = 0;
> 			SecurityBlob->DomainName.MaximumLength = 0;
> 		} else {
>-			__u16 len =
>-			    cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
>+			__u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
> 					  nls_codepage);
>-			len *= 2;
>+			ln *= 2;
> 			SecurityBlob->DomainName.MaximumLength =
>-			    cpu_to_le16(len);
>+			    cpu_to_le16(ln);
> 			SecurityBlob->DomainName.Buffer =
> 			    cpu_to_le32(SecurityBlobLength);
>-			bcc_ptr += len;
>-			SecurityBlobLength += len;
>-			SecurityBlob->DomainName.Length =
>-			    cpu_to_le16(len);
>+			bcc_ptr += ln;
>+			SecurityBlobLength += ln;
>+			SecurityBlob->DomainName.Length = cpu_to_le16(ln);
> 		}
> 		if (user == NULL) {
> 			SecurityBlob->UserName.Buffer = 0;
> 			SecurityBlob->UserName.Length = 0;
> 			SecurityBlob->UserName.MaximumLength = 0;
> 		} else {
>-			__u16 len =
>-			    cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
>+			__u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
> 					  nls_codepage);
>-			len *= 2;
>+			ln *= 2;
> 			SecurityBlob->UserName.MaximumLength =
>-			    cpu_to_le16(len);
>+			    cpu_to_le16(ln);
> 			SecurityBlob->UserName.Buffer =
> 			    cpu_to_le32(SecurityBlobLength);
>-			bcc_ptr += len;
>-			SecurityBlobLength += len;
>-			SecurityBlob->UserName.Length =
>-			    cpu_to_le16(len);
>+			bcc_ptr += ln;
>+			SecurityBlobLength += ln;
>+			SecurityBlob->UserName.Length = cpu_to_le16(ln);
> 		}
> 
>-		/* SecurityBlob->WorkstationName.Length = cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
>+		/* SecurityBlob->WorkstationName.Length =
>+		 cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
> 		   SecurityBlob->WorkstationName.Length *= 2;
>-		   SecurityBlob->WorkstationName.MaximumLength = cpu_to_le16(SecurityBlob->WorkstationName.Length);
>-		   SecurityBlob->WorkstationName.Buffer = cpu_to_le32(SecurityBlobLength);
>+		   SecurityBlob->WorkstationName.MaximumLength =
>+			cpu_to_le16(SecurityBlob->WorkstationName.Length);
>+		   SecurityBlob->WorkstationName.Buffer =
>+				 cpu_to_le32(SecurityBlobLength);
> 		   bcc_ptr += SecurityBlob->WorkstationName.Length;
> 		   SecurityBlobLength += SecurityBlob->WorkstationName.Length;
>-		   SecurityBlob->WorkstationName.Length = cpu_to_le16(SecurityBlob->WorkstationName.Length);  */
>+		   SecurityBlob->WorkstationName.Length =
>+			cpu_to_le16(SecurityBlob->WorkstationName.Length);  */
> 
> 		if ((long) bcc_ptr % 2) {
> 			*bcc_ptr = 0;
>@@ -2954,10 +3139,9 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 				  32, nls_codepage);
> 		bcc_ptr += 2 * bytes_returned;
> 		bytes_returned =
>-
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 18)
> 		    cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
>-                                  nls_codepage);
>+				  nls_codepage);
> #else
> 		    cifs_strtoUCS((__le16 *) bcc_ptr, system_utsname.release, 32,
> 				  nls_codepage);
>@@ -2980,33 +3164,32 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 			SecurityBlob->DomainName.Length = 0;
> 			SecurityBlob->DomainName.MaximumLength = 0;
> 		} else {
>-			__u16 len;
>+			__u16 ln;
> 			negotiate_flags |= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
> 			strncpy(bcc_ptr, domain, 63);
>-			len = strnlen(domain, 64);
>+			ln = strnlen(domain, 64);
> 			SecurityBlob->DomainName.MaximumLength =
>-			    cpu_to_le16(len);
>+			    cpu_to_le16(ln);
> 			SecurityBlob->DomainName.Buffer =
> 			    cpu_to_le32(SecurityBlobLength);
>-			bcc_ptr += len;
>-			SecurityBlobLength += len;
>-			SecurityBlob->DomainName.Length = cpu_to_le16(len);
>+			bcc_ptr += ln;
>+			SecurityBlobLength += ln;
>+			SecurityBlob->DomainName.Length = cpu_to_le16(ln);
> 		}
> 		if (user == NULL) {
> 			SecurityBlob->UserName.Buffer = 0;
> 			SecurityBlob->UserName.Length = 0;
> 			SecurityBlob->UserName.MaximumLength = 0;
> 		} else {
>-			__u16 len;
>+			__u16 ln;
> 			strncpy(bcc_ptr, user, 63);
>-			len = strnlen(user, 64);
>-			SecurityBlob->UserName.MaximumLength =
>-			    cpu_to_le16(len);
>+			ln = strnlen(user, 64);
>+			SecurityBlob->UserName.MaximumLength = cpu_to_le16(ln);
> 			SecurityBlob->UserName.Buffer =
>-			    cpu_to_le32(SecurityBlobLength);
>-			bcc_ptr += len;
>-			SecurityBlobLength += len;
>-			SecurityBlob->UserName.Length = cpu_to_le16(len);
>+						cpu_to_le32(SecurityBlobLength);
>+			bcc_ptr += ln;
>+			SecurityBlobLength += ln;
>+			SecurityBlob->UserName.Length = cpu_to_le16(ln);
> 		}
> 		/* BB fill in our workstation name if known BB */
> 
>@@ -3040,17 +3223,20 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 		__u16 blob_len =
> 		    le16_to_cpu(pSMBr->resp.SecurityBlobLength);
> 		if (action & GUEST_LOGIN)
>-			cFYI(1, (" Guest login"));	/* BB do we want to set anything in SesInfo struct ? */
>-/*        if(SecurityBlob2->MessageType != NtLm??){                               
>-                 cFYI("Unexpected message type on auth response is %d ")); 
>-        } */
>+			cFYI(1, (" Guest login")); /* BB Should we set anything
>+							 in SesInfo struct ? */
>+/*		if (SecurityBlob2->MessageType != NtLm??) {
>+			cFYI("Unexpected message type on auth response is %d"));
>+		} */
>+
> 		if (ses) {
> 			cFYI(1,
>-			     ("Does UID on challenge %d match auth response UID %d ",
>+			     ("Check challenge UID %d vs auth response UID %d",
> 			      ses->Suid, smb_buffer_response->Uid));
>-			ses->Suid = smb_buffer_response->Uid; /* UID left in wire format */
>-			bcc_ptr = pByteArea(smb_buffer_response);	
>-            /* response can have either 3 or 4 word count - Samba sends 3 */
>+			/* UID left in wire format */
>+			ses->Suid = smb_buffer_response->Uid;
>+			bcc_ptr = pByteArea(smb_buffer_response);
>+		/* response can have either 3 or 4 word count - Samba sends 3 */
> 			if ((pSMBr->resp.hdr.WordCount == 3)
> 			    || ((pSMBr->resp.hdr.WordCount == 4)
> 				&& (blob_len <
>@@ -3075,12 +3261,12 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 					} else {
> 						remaining_words = BCC(smb_buffer_response) / 2;
> 					}
>-					len =
>-					    UniStrnlen((wchar_t *) bcc_ptr,remaining_words - 1);
>+					len = UniStrnlen((wchar_t *) bcc_ptr,
>+							remaining_words - 1);
> /* We look for obvious messed up bcc or strings in response so we do not go off
>   the end since (at least) WIN2K and Windows XP have a major bug in not null
>   terminating last Unicode string in response  */
>-					if(ses->serverOS)
>+					if (ses->serverOS)
> 						kfree(ses->serverOS);
> 					ses->serverOS =
> 					    kzalloc(2 * (len + 1), GFP_KERNEL);
>@@ -3112,9 +3298,9 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 						ses->serverNOS[1+(2*len)] = 0;
> 						remaining_words -= len + 1;
> 						if (remaining_words > 0) {
>-							len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);	
>+							len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
>      /* last string not always null terminated (e.g. for Windows XP & 2000) */
>-							if(ses->serverDomain)
>+							if (ses->serverDomain)
> 								kfree(ses->serverDomain);
> 							ses->serverDomain =
> 							    kzalloc(2 *
>@@ -3142,12 +3328,12 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 							    = 0;
> 						} /* else no more room so create dummy domain string */
> 						else {
>-							if(ses->serverDomain)
>+							if (ses->serverDomain)
> 								kfree(ses->serverDomain);
> 							ses->serverDomain = kzalloc(2,GFP_KERNEL);
> 						}
> 					} else {  /* no room so create dummy domain and NOS string */
>-						if(ses->serverDomain)
>+						if (ses->serverDomain)
> 							kfree(ses->serverDomain);
> 						ses->serverDomain = kzalloc(2, GFP_KERNEL);
> 						kfree(ses->serverNOS);
>@@ -3155,12 +3341,12 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 					}
> 				} else {	/* ASCII */
> 					len = strnlen(bcc_ptr, 1024);
>-					if (((long) bcc_ptr + len) - 
>-                        (long) pByteArea(smb_buffer_response) 
>-                            <= BCC(smb_buffer_response)) {
>-						if(ses->serverOS)
>+					if (((long) bcc_ptr + len) -
>+					   (long) pByteArea(smb_buffer_response)
>+						<= BCC(smb_buffer_response)) {
>+						if (ses->serverOS)
> 							kfree(ses->serverOS);
>-						ses->serverOS = kzalloc(len + 1,GFP_KERNEL);
>+						ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
> 						strncpy(ses->serverOS,bcc_ptr, len);
> 
> 						bcc_ptr += len;
>@@ -3169,28 +3355,35 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
> 
> 						len = strnlen(bcc_ptr, 1024);
> 						kfree(ses->serverNOS);
>-						ses->serverNOS = kzalloc(len+1,GFP_KERNEL);
>-						strncpy(ses->serverNOS, bcc_ptr, len);	
>+						ses->serverNOS = kzalloc(len+1,
>+								    GFP_KERNEL);
>+						strncpy(ses->serverNOS,
>+							bcc_ptr, len);
> 						bcc_ptr += len;
> 						bcc_ptr[0] = 0;
> 						bcc_ptr++;
> 
> 						len = strnlen(bcc_ptr, 1024);
>-						if(ses->serverDomain)
>+						if (ses->serverDomain)
> 							kfree(ses->serverDomain);
>-						ses->serverDomain = kzalloc(len+1,GFP_KERNEL);
>-						strncpy(ses->serverDomain, bcc_ptr, len);
>+						ses->serverDomain =
>+								kzalloc(len+1,
>+								    GFP_KERNEL);
>+						strncpy(ses->serverDomain,
>+							bcc_ptr, len);
> 						bcc_ptr += len;
> 						bcc_ptr[0] = 0;
> 						bcc_ptr++;
> 					} else
> 						cFYI(1,
>-						     ("Variable field of length %d extends beyond end of smb ",
>+						     ("field of length %d "
>+						   "extends beyond end of smb ",
> 						      len));
> 				}
> 			} else {
> 				cERROR(1,
>-				       (" Security Blob Length extends beyond end of SMB"));
>+				       (" Security Blob extends beyond end "
>+					"of SMB"));
> 			}
> 		} else {
> 			cERROR(1, ("No session structure passed in."));
>@@ -3242,7 +3435,7 @@ CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
> 	pSMB->AndXCommand = 0xFF;
> 	pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
> 	bcc_ptr = &pSMB->Password[0];
>-	if((ses->server->secMode) & SECMODE_USER) {
>+	if ((ses->server->secMode) & SECMODE_USER) {
> 		pSMB->PasswordLength = cpu_to_le16(1);	/* minimum */
> 		*bcc_ptr = 0; /* password is null byte */
> 		bcc_ptr++;              /* skip password */
>@@ -3256,7 +3449,7 @@ CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
> 		   by Samba (not sure whether other servers allow
> 		   NTLMv2 password here) */
> #ifdef CONFIG_CIFS_WEAK_PW_HASH
>-		if((extended_security & CIFSSEC_MAY_LANMAN) && 
>+		if ((extended_security & CIFSSEC_MAY_LANMAN) &&
> 			(ses->server->secType == LANMAN))
> 			calc_lanman_hash(ses, bcc_ptr);
> 		else
>@@ -3266,14 +3459,14 @@ CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
> 			     bcc_ptr);
> 
> 		bcc_ptr += CIFS_SESS_KEY_SIZE;
>-		if(ses->capabilities & CAP_UNICODE) {
>+		if (ses->capabilities & CAP_UNICODE) {
> 			/* must align unicode strings */
> 			*bcc_ptr = 0; /* null byte password */
> 			bcc_ptr++;
> 		}
> 	}
> 
>-	if(ses->server->secMode & 
>+	if (ses->server->secMode &
> 			(SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
> 		smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
> 
>@@ -3286,8 +3479,8 @@ CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
> 	if (ses->capabilities & CAP_UNICODE) {
> 		smb_buffer->Flags2 |= SMBFLG2_UNICODE;
> 		length =
>-		    cifs_strtoUCS((__le16 *) bcc_ptr, tree, 
>-			6 /* max utf8 char length in bytes */ * 
>+		    cifs_strtoUCS((__le16 *) bcc_ptr, tree,
>+			6 /* max utf8 char length in bytes */ *
> 			(/* server len*/ + 256 /* share len */), nls_codepage);
> 		bcc_ptr += 2 * length;	/* convert num 16 bit words to bytes */
> 		bcc_ptr += 2;	/* skip trailing null */
>@@ -3311,8 +3504,8 @@ CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
> 		tcon->tid = smb_buffer_response->Tid;
> 		bcc_ptr = pByteArea(smb_buffer_response);
> 		length = strnlen(bcc_ptr, BCC(smb_buffer_response) - 2);
>-        /* skip service field (NB: this field is always ASCII) */
>-		bcc_ptr += length + 1;	
>+		/* skip service field (NB: this field is always ASCII) */
>+		bcc_ptr += length + 1;
> 		strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
> 		if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
> 			length = UniStrnlen((wchar_t *) bcc_ptr, 512);
>@@ -3322,15 +3515,17 @@ CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
> 				kfree(tcon->nativeFileSystem);
> 				tcon->nativeFileSystem =
> 				    kzalloc(length + 2, GFP_KERNEL);
>-				cifs_strfromUCS_le(tcon->nativeFileSystem,
>-						   (__le16 *) bcc_ptr,
>-						   length, nls_codepage);
>+				if (tcon->nativeFileSystem)
>+					cifs_strfromUCS_le(
>+						tcon->nativeFileSystem,
>+						(__le16 *) bcc_ptr,
>+						length, nls_codepage);
> 				bcc_ptr += 2 * length;
> 				bcc_ptr[0] = 0;	/* null terminate the string */
> 				bcc_ptr[1] = 0;
> 				bcc_ptr += 2;
> 			}
>-			/* else do not bother copying these informational fields */
>+			/* else do not bother copying these information fields*/
> 		} else {
> 			length = strnlen(bcc_ptr, 1024);
> 			if ((bcc_ptr + length) -
>@@ -3339,12 +3534,13 @@ CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
> 				kfree(tcon->nativeFileSystem);
> 				tcon->nativeFileSystem =
> 				    kzalloc(length + 1, GFP_KERNEL);
>-				strncpy(tcon->nativeFileSystem, bcc_ptr,
>-					length);
>+				if (tcon->nativeFileSystem)
>+					strncpy(tcon->nativeFileSystem, bcc_ptr,
>+						length);
> 			}
>-			/* else do not bother copying these informational fields */
>+			/* else do not bother copying these information fields*/
> 		}
>-		if((smb_buffer_response->WordCount == 3) ||
>+		if ((smb_buffer_response->WordCount == 3) ||
> 			 (smb_buffer_response->WordCount == 7))
> 			/* field is in same location */
> 			tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
>@@ -3352,7 +3548,7 @@ CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
> 			tcon->Flags = 0;
> 		cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
> 	} else if ((rc == 0) && tcon == NULL) {
>-        /* all we need to save for IPC$ connection */
>+		/* all we need to save for IPC$ connection */
> 		ses->ipc_tid = smb_buffer_response->Tid;
> 	}
> 
>@@ -3368,7 +3564,7 @@ cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
> 	int xid;
> 	struct cifsSesInfo *ses = NULL;
> 	struct task_struct *cifsd_task;
>-	char * tmp;
>+	char *tmp;
> 
> 	xid = GetXid();
> 
>@@ -3389,10 +3585,10 @@ cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
> 				FreeXid(xid);
> 				return 0;
> 			} else if (rc == -ESHUTDOWN) {
>-				cFYI(1,("Waking up socket by sending it signal"));
>-				if(cifsd_task) {
>-					force_sig(SIGKILL,cifsd_task);
>-					wait_for_completion(&cifsd_complete);
>+				cFYI(1, ("Waking up socket by sending signal"));
>+				if (cifsd_task) {
>+					force_sig(SIGKILL, cifsd_task);
>+					kthread_stop(cifsd_task);
> 				}
> 				rc = 0;
> 			} /* else - we have an smb session
>@@ -3400,7 +3596,7 @@ cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
> 		} else
> 			cFYI(1, ("No session or bad tcon"));
> 	}
>-	
>+
> 	cifs_sb->tcon = NULL;
> 	tmp = cifs_sb->prepath;
> 	cifs_sb->prepathlen = 0;
>@@ -3417,11 +3613,11 @@ cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
> 		sesInfoFree(ses);
> 
> 	FreeXid(xid);
>-	return rc;		/* BB check if we should always return zero here */
>-} 
>+	return rc;	/* BB check if we should always return zero here */
>+}
> 
> int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
>-					   struct nls_table * nls_info)
>+					   struct nls_table *nls_info)
> {
> 	int rc = 0;
> 	char ntlm_session_key[CIFS_SESS_KEY_SIZE];
>@@ -3429,16 +3625,16 @@ int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
> 	int first_time = 0;
> 
> 	/* what if server changes its buffer size after dropping the session? */
>-	if(pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
>+	if (pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
> 		rc = CIFSSMBNegotiate(xid, pSesInfo);
>-		if(rc == -EAGAIN) /* retry only once on 1st time connection */ {
>+		if (rc == -EAGAIN) /* retry only once on 1st time connection */ {
> 			rc = CIFSSMBNegotiate(xid, pSesInfo);
>-			if(rc == -EAGAIN) 
>+			if (rc == -EAGAIN)
> 				rc = -EHOSTDOWN;
> 		}
>-		if(rc == 0) {
>+		if (rc == 0) {
> 			spin_lock(&GlobalMid_Lock);
>-			if(pSesInfo->server->tcpStatus != CifsExiting)
>+			if (pSesInfo->server->tcpStatus != CifsExiting)
> 				pSesInfo->server->tcpStatus = CifsGood;
> 			else
> 				rc = -EHOSTDOWN;
>@@ -3450,18 +3646,19 @@ int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
> 	if (!rc) {
> 		pSesInfo->flags = 0;
> 		pSesInfo->capabilities = pSesInfo->server->capabilities;
>-		if(linuxExtEnabled == 0)
>+		if (linuxExtEnabled == 0)
> 			pSesInfo->capabilities &= (~CAP_UNIX);
> 	/*	pSesInfo->sequence_number = 0;*/
>-		cFYI(1,("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
>+		cFYI(1,
>+		      ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
> 			pSesInfo->server->secMode,
> 			pSesInfo->server->capabilities,
> 			pSesInfo->server->timeAdj));
>-		if(experimEnabled < 2)
>+		if (experimEnabled < 2)
> 			rc = CIFS_SessSetup(xid, pSesInfo,
> 					    first_time, nls_info);
> 		else if (extended_security
>-				&& (pSesInfo->capabilities 
>+				&& (pSesInfo->capabilities
> 					& CAP_EXTENDED_SECURITY)
> 				&& (pSesInfo->server->secType == NTLMSSP)) {
> 			rc = -EOPNOTSUPP;
>@@ -3474,21 +3671,22 @@ int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
> 						&ntlmv2_flag,
> 						nls_info);
> 			if (!rc) {
>-				if(ntlmv2_flag) {
>-					char * v2_response;
>-					cFYI(1,("more secure NTLM ver2 hash"));
>-					if(CalcNTLMv2_partial_mac_key(pSesInfo, 
>+				if (ntlmv2_flag) {
>+					char *v2_response;
>+					cFYI(1, ("more secure NTLM ver2 hash"));
>+					if (CalcNTLMv2_partial_mac_key(pSesInfo,
> 						nls_info)) {
> 						rc = -ENOMEM;
> 						goto ss_err_exit;
> 					} else
> 						v2_response = kmalloc(16 + 64 /* blob */, GFP_KERNEL);
>-					if(v2_response) {
>-						CalcNTLMv2_response(pSesInfo,v2_response);
>-				/*		if(first_time)
>-							cifs_calculate_ntlmv2_mac_key(
>-							  pSesInfo->server->mac_signing_key, 
>-							  response, ntlm_session_key, */
>+					if (v2_response) {
>+						CalcNTLMv2_response(pSesInfo,
>+								   v2_response);
>+				/*		if (first_time)
>+						  cifs_calculate_ntlmv2_mac_key(
>+						   pSesInfo->server->mac_signing_key,
>+						   response, ntlm_session_key,*/
> 						kfree(v2_response);
> 					/* BB Put dummy sig in SessSetup PDU? */
> 					} else {
>@@ -3501,9 +3699,9 @@ int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
> 						pSesInfo->server->cryptKey,
> 						ntlm_session_key);
> 
>-					if(first_time)
>+					if (first_time)
> 						cifs_calculate_mac_key(
>-							pSesInfo->server->mac_signing_key,
>+							&pSesInfo->server->mac_signing_key,
> 							ntlm_session_key,
> 							pSesInfo->password);
> 				}
>@@ -3521,18 +3719,18 @@ int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
> 				pSesInfo->server->cryptKey,
> 				ntlm_session_key);
> 
>-			if(first_time) 		
>+			if (first_time)
> 				cifs_calculate_mac_key(
>-					pSesInfo->server->mac_signing_key,
>+					&pSesInfo->server->mac_signing_key,
> 					ntlm_session_key, pSesInfo->password);
> 
> 			rc = CIFSSessSetup(xid, pSesInfo,
> 				ntlm_session_key, nls_info);
> 		}
> 		if (rc) {
>-			cERROR(1,("Send error in SessSetup = %d",rc));
>+			cERROR(1, ("Send error in SessSetup = %d", rc));
> 		} else {
>-			cFYI(1,("CIFS Session Established successfully"));
>+			cFYI(1, ("CIFS Session Established successfully"));
> 			pSesInfo->status = CifsGood;
> 		}
> 	}
>diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
>index 0037dea..6671ade 100644
>--- a/fs/cifs/dir.c
>+++ b/fs/cifs/dir.c
>@@ -2,7 +2,7 @@
>  *   fs/cifs/dir.c
>  *
>  *   vfs operations that deal with dentries
>- * 
>+ *
>  *   Copyright (C) International Business Machines  Corp., 2002,2005
>  *   Author(s): Steve French (sfrench@us.ibm.com)
>  *
>@@ -40,11 +40,12 @@
> static void
> renew_parental_timestamps(struct dentry *direntry)
> {
>-	/* BB check if there is a way to get the kernel to do this or if we really need this */
>+	/* BB check if there is a way to get the kernel to do this or if we
>+	   really need this */
> 	do {
> 		direntry->d_time = jiffies;
> 		direntry = direntry->d_parent;
>-	} while (!IS_ROOT(direntry));	
>+	} while (!IS_ROOT(direntry));
> }
> 
> /* Note: caller must free return buffer */
>@@ -57,7 +58,7 @@ build_path_from_dentry(struct dentry *direntry)
> 	char *full_path;
> 	char dirsep;
> 
>-	if(direntry == NULL)
>+	if (direntry == NULL)
> 		return NULL;  /* not much we can do if dentry is freed and
> 		we need to reopen the file after it was closed implicitly
> 		when the server crashed */
>@@ -65,18 +66,18 @@ build_path_from_dentry(struct dentry *direntry)
> 	dirsep = CIFS_DIR_SEP(CIFS_SB(direntry->d_sb));
> 	pplen = CIFS_SB(direntry->d_sb)->prepathlen;
> cifs_bp_rename_retry:
>-	namelen = pplen; 
>+	namelen = pplen;
> 	for (temp = direntry; !IS_ROOT(temp);) {
> 		namelen += (1 + temp->d_name.len);
> 		temp = temp->d_parent;
>-		if(temp == NULL) {
>-			cERROR(1,("corrupt dentry"));
>+		if (temp == NULL) {
>+			cERROR(1, ("corrupt dentry"));
> 			return NULL;
> 		}
> 	}
> 
> 	full_path = kmalloc(namelen+1, GFP_KERNEL);
>-	if(full_path == NULL)
>+	if (full_path == NULL)
> 		return full_path;
> 	full_path[namelen] = 0;	/* trailing null */
> 	for (temp = direntry; !IS_ROOT(temp);) {
>@@ -90,8 +91,8 @@ cifs_bp_rename_retry:
> 			cFYI(0, ("name: %s", full_path + namelen));
> 		}
> 		temp = temp->d_parent;
>-		if(temp == NULL) {
>-			cERROR(1,("corrupt dentry"));
>+		if (temp == NULL) {
>+			cERROR(1, ("corrupt dentry"));
> 			kfree(full_path);
> 			return NULL;
> 		}
>@@ -100,7 +101,7 @@ cifs_bp_rename_retry:
> 		cERROR(1,
> 		       ("did not end path lookup where expected namelen is %d",
> 			namelen));
>-		/* presumably this is only possible if racing with a rename 
>+		/* presumably this is only possible if racing with a rename
> 		of one of the parent directories  (we can not lock the dentries
> 		above us to prevent this, but retrying should be harmless) */
> 		kfree(full_path);
>@@ -112,7 +113,7 @@ cifs_bp_rename_retry:
> 	   since the '\' is a valid posix character so we can not switch
> 	   those safely to '/' if any are found in the middle of the prepath */
> 	/* BB test paths to Windows with '/' in the midst of prepath */
>-	strncpy(full_path,CIFS_SB(direntry->d_sb)->prepath,pplen);
>+	strncpy(full_path, CIFS_SB(direntry->d_sb)->prepath, pplen);
> 	return full_path;
> }
> 
>@@ -144,22 +145,22 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode)
> 	struct cifs_sb_info *cifs_sb;
> 	struct cifsTconInfo *pTcon;
> 	char *full_path = NULL;
>-	FILE_ALL_INFO * buf = NULL;
>+	FILE_ALL_INFO *buf = NULL;
> 	struct inode *newinode = NULL;
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
>-	struct cifsFileInfo * pCifsFile = NULL;
>-	struct cifsInodeInfo * pCifsInode;
>+	struct cifsFileInfo *pCifsFile = NULL;
>+	struct cifsInodeInfo *pCifsInode;
> 	int write_only = FALSE;
> #endif
> 	int disposition = FILE_OVERWRITE_IF;
>-
>+	
> 	xid = GetXid();
> 
> 	cifs_sb = CIFS_SB(inode->i_sb);
> 	pTcon = cifs_sb->tcon;
> 
> 	full_path = build_path_from_dentry(direntry);
>-	if(full_path == NULL) {
>+	if (full_path == NULL) {
> 		FreeXid(xid);
> 		return -ENOMEM;
> 	}
>@@ -181,31 +182,32 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode)
> 				write_only = TRUE;
> 		}
> 
>-		if((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
>+		if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
> 			disposition = FILE_CREATE;
>-		else if((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
>+		else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
> 			disposition = FILE_OVERWRITE_IF;
>-		else if((oflags & O_CREAT) == O_CREAT)
>+		else if ((oflags & O_CREAT) == O_CREAT)
> 			disposition = FILE_OPEN_IF;
> 		else {
>-			cFYI(1,("Create flag not set in create function"));
>+			cFYI(1, ("Create flag not set in create function"));
> 		}
> 	}
> 
>-	/* BB add processing to set equivalent of mode - e.g. via CreateX with ACLs */
>+	/* BB add processing to set equivalent of mode - e.g. via CreateX with
>+	   ACLs */
> 	if (oplockEnabled)
> 		oplock = REQ_OPLOCK;
> #else
> 	desiredAccess = GENERIC_WRITE;
> #endif
> 
>-	buf = kmalloc(sizeof(FILE_ALL_INFO),GFP_KERNEL);
>-	if(buf == NULL) {
>+	buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
>+	if (buf == NULL) {
> 		kfree(full_path);
> 		FreeXid(xid);
> 		return -ENOMEM;
> 	}
>-	if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS) 
>+	if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
> 		rc = CIFSSMBOpen(xid, pTcon, full_path, disposition,
> 			 desiredAccess, CREATE_NOT_DIR,
> 			 &fileHandle, &oplock, buf, cifs_sb->local_nls,
>@@ -213,28 +215,27 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode)
> 	else
> 		rc = -EIO; /* no NT SMB support fall into legacy open below */
> 
>-	if(rc == -EIO) {
>+	if (rc == -EIO) {
> 		/* old server, retry the open legacy style */
> 		rc = SMBLegacyOpen(xid, pTcon, full_path, disposition,
> 			desiredAccess, CREATE_NOT_DIR,
> 			&fileHandle, &oplock, buf, cifs_sb->local_nls,
> 			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
>-	} 
>+	}
> 	if (rc) {
> 		cFYI(1, ("cifs_create returned 0x%x", rc));
> 	} else {
> 		/* If Open reported that we actually created a file
> 		then we now have to set the mode if possible */
>-		if ((cifs_sb->tcon->ses->capabilities & CAP_UNIX) &&
>-			(oplock & CIFS_CREATE_ACTION)) {
>+		if ((pTcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {
> 			mode &= ~current->fs->umask;
>-			if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
>+			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
> 				CIFSSMBUnixSetPerms(xid, pTcon, full_path, mode,
> 					(__u64)current->fsuid,
> 					(__u64)current->fsgid,
> 					0 /* dev */,
>-					cifs_sb->local_nls, 
>-					cifs_sb->mnt_cifs_flags & 
>+					cifs_sb->local_nls,
>+					cifs_sb->mnt_cifs_flags &
> 						CIFS_MOUNT_MAP_SPECIAL_CHR);
> 			} else {
> 				CIFSSMBUnixSetPerms(xid, pTcon, full_path, mode,
>@@ -242,26 +243,28 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode)
> 					(__u64)-1,
> 					0 /* dev */,
> 					cifs_sb->local_nls,
>-					cifs_sb->mnt_cifs_flags & 
>+					cifs_sb->mnt_cifs_flags &
> 						CIFS_MOUNT_MAP_SPECIAL_CHR);
> 			}
> 		} else {
>-			/* BB implement mode setting via Windows security descriptors */
>-			/* eg CIFSSMBWinSetPerms(xid,pTcon,full_path,mode,-1,-1,local_nls);*/
>-			/* could set r/o dos attribute if mode & 0222 == 0 */
>+			/* BB implement mode setting via Windows security
>+			   descriptors e.g. */
>+			/* CIFSSMBWinSetPerms(xid,pTcon,path,mode,-1,-1,nls);*/
>+
>+			/* Could set r/o dos attribute if mode & 0222 == 0 */
> 		}
> 
>-	/* BB server might mask mode so we have to query for Unix case*/
>-		if (pTcon->ses->capabilities & CAP_UNIX)
>+		/* server might mask mode so we have to query for it */
>+		if (pTcon->unix_ext)
> 			rc = cifs_get_inode_info_unix(&newinode, full_path,
>-						 inode->i_sb,xid);
>+						 inode->i_sb, xid);
> 		else {
> 			rc = cifs_get_inode_info(&newinode, full_path,
>-						 buf, inode->i_sb,xid);
>-			if(newinode) {
>+						 buf, inode->i_sb, xid);
>+			if (newinode) {
> 				newinode->i_mode = mode;
>-				if((oplock & CIFS_CREATE_ACTION) &&
>-				  (cifs_sb->mnt_cifs_flags & 
>+				if ((oplock & CIFS_CREATE_ACTION) &&
>+				    (cifs_sb->mnt_cifs_flags &
> 				     CIFS_MOUNT_SET_UID)) {
> 					newinode->i_uid = current->fsuid;
> 					newinode->i_gid = current->fsgid;
>@@ -281,14 +284,15 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode)
> 			d_instantiate(direntry, newinode);
> 		}
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
>-		if((nd->flags & LOOKUP_OPEN) == FALSE) {
>+		if ((nd == NULL /* nfsd case - nfs srv does not set nd */) ||
>+			((nd->flags & LOOKUP_OPEN) == FALSE)) {
> 			/* mknod case - do not leave file open */
> 			CIFSSMBClose(xid, pTcon, fileHandle);
>-		} else if(newinode) {
>+		} else if (newinode) {
> 			pCifsFile =
> 			   kzalloc(sizeof (struct cifsFileInfo), GFP_KERNEL);
>-			
>-			if(pCifsFile == NULL)
>+
>+			if (pCifsFile == NULL)
> 				goto cifs_create_out;
> 			pCifsFile->netfid = fileHandle;
> 			pCifsFile->pid = current->tgid;
>@@ -296,30 +300,34 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode)
> 			pCifsFile->invalidHandle = FALSE;
> 			pCifsFile->closePend     = FALSE;
> 			init_MUTEX(&pCifsFile->fh_sem);
>-			init_MUTEX(&pCifsFile->lock_sem);
>+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)
>+			mutex_init(&pCifsFile->lock_mutex);
>+#else
>+			init_MUTEX(&pCifsFile->lock_mutex);
>+#endif
> 			INIT_LIST_HEAD(&pCifsFile->llist);
>-			atomic_set(&pCifsFile->wrtPending,0);
>+			atomic_set(&pCifsFile->wrtPending, 0);
> 
>-			/* set the following in open now 
>+			/* set the following in open now
> 				pCifsFile->pfile = file; */
> 			write_lock(&GlobalSMBSeslock);
>-			list_add(&pCifsFile->tlist,&pTcon->openFileList);
>+			list_add(&pCifsFile->tlist, &pTcon->openFileList);
> 			pCifsInode = CIFS_I(newinode);
>-			if(pCifsInode) {
>+			if (pCifsInode) {
> 				/* if readable file instance put first in list*/
> 				if (write_only == TRUE) {
>-                                       	list_add_tail(&pCifsFile->flist,
>+					list_add_tail(&pCifsFile->flist,
> 						&pCifsInode->openFileList);
> 				} else {
> 					list_add(&pCifsFile->flist,
> 						&pCifsInode->openFileList);
> 				}
>-				if((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
>+				if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
> 					pCifsInode->clientCanCacheAll = TRUE;
> 					pCifsInode->clientCanCacheRead = TRUE;
>-					cFYI(1,("Exclusive Oplock for inode %p",
>+					cFYI(1, ("Exclusive Oplock inode %p",
> 						newinode));
>-				} else if((oplock & 0xF) == OPLOCK_READ)
>+				} else if ((oplock & 0xF) == OPLOCK_READ)
> 					pCifsInode->clientCanCacheRead = TRUE;
> 			}
> 			write_unlock(&GlobalSMBSeslock);
>@@ -337,7 +345,7 @@ cifs_create_out:
> }
> 
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
>-int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode, 
>+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)
>@@ -348,7 +356,7 @@ int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode, int devic
> 	struct cifs_sb_info *cifs_sb;
> 	struct cifsTconInfo *pTcon;
> 	char *full_path = NULL;
>-	struct inode * newinode = NULL;
>+	struct inode *newinode = NULL;
> 
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
> 	if (!old_valid_dev(device_number))
>@@ -361,44 +369,45 @@ int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode, int devic
> 	pTcon = cifs_sb->tcon;
> 
> 	full_path = build_path_from_dentry(direntry);
>-	if(full_path == NULL)
>+	if (full_path == NULL)
> 		rc = -ENOMEM;
>-	else if (pTcon->ses->capabilities & CAP_UNIX) {
>+	else if (pTcon->unix_ext) {
> 		mode &= ~current->fs->umask;
>-		if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
>+		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
> 			rc = CIFSSMBUnixSetPerms(xid, pTcon, full_path,
>-				mode,(__u64)current->fsuid,(__u64)current->fsgid,
>+				mode, (__u64)current->fsuid,
>+				(__u64)current->fsgid,
> 				device_number, cifs_sb->local_nls,
>-				cifs_sb->mnt_cifs_flags & 
>+				cifs_sb->mnt_cifs_flags &
> 					CIFS_MOUNT_MAP_SPECIAL_CHR);
> 		} else {
> 			rc = CIFSSMBUnixSetPerms(xid, pTcon,
> 				full_path, mode, (__u64)-1, (__u64)-1,
> 				device_number, cifs_sb->local_nls,
>-				cifs_sb->mnt_cifs_flags & 
>+				cifs_sb->mnt_cifs_flags &
> 					CIFS_MOUNT_MAP_SPECIAL_CHR);
> 		}
> 
>-		if(!rc) {
>+		if (!rc) {
> 			rc = cifs_get_inode_info_unix(&newinode, full_path,
>-						inode->i_sb,xid);
>+						inode->i_sb, xid);
> 			if (pTcon->nocase)
> 				direntry->d_op = &cifs_ci_dentry_ops;
> 			else
> 				direntry->d_op = &cifs_dentry_ops;
>-			if(rc == 0)
>+			if (rc == 0)
> 				d_instantiate(direntry, newinode);
> 		}
> 	} else {
>-		if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
>+		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
> 			int oplock = 0;
> 			u16 fileHandle;
> 			FILE_ALL_INFO * buf;
> 
>-			cFYI(1,("sfu compat create special file"));
>+			cFYI(1, ("sfu compat create special file"));
> 
>-			buf = kmalloc(sizeof(FILE_ALL_INFO),GFP_KERNEL);
>-			if(buf == NULL) {
>+			buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
>+			if (buf == NULL) {
> 				kfree(full_path);
> 				FreeXid(xid);
> 				return -ENOMEM;
>@@ -406,39 +415,38 @@ int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode, int devic
> 
> 			rc = CIFSSMBOpen(xid, pTcon, full_path,
> 					 FILE_CREATE, /* fail if exists */
>-					 GENERIC_WRITE /* BB would 
>+					 GENERIC_WRITE /* BB would
> 					  WRITE_OWNER | WRITE_DAC be better? */,
> 					 /* Create a file and set the
> 					    file attribute to SYSTEM */
> 					 CREATE_NOT_DIR | CREATE_OPTION_SPECIAL,
> 					 &fileHandle, &oplock, buf,
> 					 cifs_sb->local_nls,
>-					 cifs_sb->mnt_cifs_flags & 
>+					 cifs_sb->mnt_cifs_flags &
> 					    CIFS_MOUNT_MAP_SPECIAL_CHR);
> 
> 			/* BB FIXME - add handling for backlevel servers
> 			   which need legacy open and check for all
>-			   calls to SMBOpen for fallback to 
>-			   SMBLeagcyOpen */
>-			if(!rc) {
>+			   calls to SMBOpen for fallback to SMBLeagcyOpen */
>+			if (!rc) {
> 				/* BB Do not bother to decode buf since no
> 				   local inode yet to put timestamps in,
> 				   but we can reuse it safely */
>-				int bytes_written;
>+				unsigned int bytes_written;
> 				struct win_dev *pdev;
> 				pdev = (struct win_dev *)buf;
>-				if(S_ISCHR(mode)) {
>+				if (S_ISCHR(mode)) {
> 					memcpy(pdev->type, "IntxCHR", 8);
> 					pdev->major =
> 					      cpu_to_le64(MAJOR(device_number));
>-					pdev->minor = 
>+					pdev->minor =
> 					      cpu_to_le64(MINOR(device_number));
> 					rc = CIFSSMBWrite(xid, pTcon,
> 						fileHandle,
> 						sizeof(struct win_dev),
> 						0, &bytes_written, (char *)pdev,
> 						NULL, 0);
>-				} else if(S_ISBLK(mode)) {
>+				} else if (S_ISBLK(mode)) {
> 					memcpy(pdev->type, "IntxBLK", 8);
> 					pdev->major =
> 					      cpu_to_le64(MAJOR(device_number));
>@@ -465,7 +473,8 @@ int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode, int devic
> 
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
> struct dentry *
>-cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry, struct nameidata *nd)
>+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)
>@@ -484,8 +493,6 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry)
> 	     (" parent inode = 0x%p name is: %s and dentry = 0x%p",
> 	      parent_dir_inode, direntry->d_name.name, direntry));
> 
>-	/* BB Add check of incoming data - e.g. frame not longer than maximum SMB - let server check the namelen BB */
>-
> 	/* check whether path exists */
> 
> 	cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
>@@ -509,7 +516,7 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry)
> 	deadlock in the cases (beginning of sys_rename itself)
> 	in which we already have the sb rename sem */
> 	full_path = build_path_from_dentry(direntry);
>-	if(full_path == NULL) {
>+	if (full_path == NULL) {
> 		FreeXid(xid);
> 		return ERR_PTR(-ENOMEM);
> 	}
>@@ -522,12 +529,12 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry)
> 	cFYI(1,
> 	     (" Full path: %s inode = 0x%p", full_path, direntry->d_inode));
> 
>-	if (pTcon->ses->capabilities & CAP_UNIX)
>+	if (pTcon->unix_ext)
> 		rc = cifs_get_inode_info_unix(&newInode, full_path,
>-					      parent_dir_inode->i_sb,xid);
>+					      parent_dir_inode->i_sb, xid);
> 	else
> 		rc = cifs_get_inode_info(&newInode, full_path, NULL,
>-					 parent_dir_inode->i_sb,xid);
>+					 parent_dir_inode->i_sb, xid);
> 
> 	if ((rc == 0) && (newInode != NULL)) {
> 		if (pTcon->nocase)
>@@ -536,7 +543,7 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry)
> 			direntry->d_op = &cifs_dentry_ops;
> 		d_add(direntry, newInode);
> 
>-		/* since paths are not looked up by component - the parent 
>+		/* since paths are not looked up by component - the parent
> 		   directories are presumed to be good here */
> 		renew_parental_timestamps(direntry);
> 
>@@ -548,13 +555,13 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry)
> 		else
> 			direntry->d_op = &cifs_dentry_ops;
> 		d_add(direntry, NULL);
>-	/*	if it was once a directory (but how can we tell?) we could do  
>-			shrink_dcache_parent(direntry); */
>+	/*	if it was once a directory (but how can we tell?) we could do
>+		shrink_dcache_parent(direntry); */
> 	} else {
>-		cERROR(1,("Error 0x%x on cifs_get_inode_info in lookup of %s",
>-			   rc,full_path));
>-		/* BB special case check for Access Denied - watch security 
>-		exposure of returning dir info implicitly via different rc 
>+		cERROR(1, ("Error 0x%x on cifs_get_inode_info in lookup of %s",
>+			   rc, full_path));
>+		/* BB special case check for Access Denied - watch security
>+		exposure of returning dir info implicitly via different rc
> 		if file exists or not but no access BB */
> 	}
> 
>@@ -580,11 +587,11 @@ cifs_d_revalidate(struct dentry *direntry, int flags)
> 	} else {
> 		cFYI(1, ("neg dentry 0x%p name = %s",
> 			 direntry, direntry->d_name.name));
>-		if(time_after(jiffies, direntry->d_time + HZ) || 
>+		if (time_after(jiffies, direntry->d_time + HZ) ||
> 			!lookupCacheEnabled) {
> 			d_drop(direntry);
> 			isValid = 0;
>-		} 
>+		}
> 	}
> 
> 	return isValid;
>@@ -601,8 +608,7 @@ cifs_d_revalidate(struct dentry *direntry, int flags)
> 
> struct dentry_operations cifs_dentry_ops = {
> 	.d_revalidate = cifs_d_revalidate,
>-/* d_delete:       cifs_d_delete,       *//* not needed except for debugging */
>-	/* no need for d_hash, d_compare, d_release, d_iput ... yet. BB confirm this BB */
>+/* d_delete:       cifs_d_delete,      */ /* not needed except for debugging */
> };
> 
> #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,9)
>diff --git a/fs/cifs/export.c b/fs/cifs/export.c
>index 1d71639..2a3f515 100644
>--- a/fs/cifs/export.c
>+++ b/fs/cifs/export.c
>@@ -5,7 +5,7 @@
>  *   Author(s): Steve French (sfrench@us.ibm.com)
>  *
>  *   Common Internet FileSystem (CIFS) client
>- * 
>+ *
>  *   Operations related to support for exporting files via NFSD
>  *
>  *   This library is free software; you can redistribute it and/or modify
>@@ -22,31 +22,49 @@
>  *   along with this library; if not, write to the Free Software
>  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>  */
>- 
>- /* 
>+
>+ /*
>   * See Documentation/filesystems/Exporting
>   * and examples in fs/exportfs
>+  *
>+  * Since cifs is a network file system, an "fsid" must be included for
>+  * any nfs exports file entries which refer to cifs paths.  In addition
>+  * the cifs mount must be mounted with the "serverino" option (ie use stable
>+  * server inode numbers instead of locally generated temporary ones).
>+  * Although cifs inodes do not use generation numbers (have generation number
>+  * of zero) - the inode number alone should be good enough for simple cases
>+  * in which users want to export cifs shares with NFS. The decode and encode
>+  * could be improved by using a new routine which expects 64 bit inode numbers
>+  * instead of the default 32 bit routines in fs/exportfs
>+  *
>   */
> 
> #include <linux/fs.h>
>- 
>+#include "cifsglob.h"
>+#include "cifs_debug.h"
>+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22)
>+#include <linux/exportfs.h>
>+#endif
>+
>+
> #ifdef CONFIG_CIFS_EXPERIMENTAL
>- 
>+
> static struct dentry *cifs_get_parent(struct dentry *dentry)
> {
>- 	/* BB need to add code here eventually to enable export via NFSD */
>- 	return ERR_PTR(-EACCES);
>+	/* BB need to add code here eventually to enable export via NFSD */
>+	cFYI(1, ("get parent for %p", dentry));
>+	return ERR_PTR(-EACCES);
> }
>- 
>+
> struct export_operations cifs_export_ops = {
>- 	.get_parent = cifs_get_parent,
>-/*	Following five export operations are unneeded so far and can default */ 	
>-/* 	.get_dentry =
>- 	.get_name =
>- 	.find_exported_dentry =
>- 	.decode_fh = 
>- 	.encode_fs =  */
>- };
>- 
>+	.get_parent = cifs_get_parent,
>+/*	Following five export operations are unneeded so far and can default:
>+	.get_dentry =
>+	.get_name =
>+	.find_exported_dentry =
>+	.decode_fh =
>+	.encode_fs =  */
>+};
>+
> #endif /* EXPERIMENTAL */
>- 
>+
>diff --git a/fs/cifs/fcntl.c b/fs/cifs/fcntl.c
>index d91a3d4..5093758 100644
>--- a/fs/cifs/fcntl.c
>+++ b/fs/cifs/fcntl.c
>@@ -2,7 +2,7 @@
>  *   fs/cifs/fcntl.c
>  *
>  *   vfs operations that deal with the file control API
>- * 
>+ *
>  *   Copyright (C) International Business Machines  Corp., 2003,2004
>  *   Author(s): Steve French (sfrench@us.ibm.com)
>  *
>@@ -35,39 +35,38 @@ static __u32 convert_to_cifs_notify_flags(unsigned long fcntl_notify_flags)
> 
> 	/* No way on Linux VFS to ask to monitor xattr
> 	changes (and no stream support either */
>-	if(fcntl_notify_flags & DN_ACCESS) {
>+	if (fcntl_notify_flags & DN_ACCESS) {
> 		cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
> 	}
>-	if(fcntl_notify_flags & DN_MODIFY) {
>+	if (fcntl_notify_flags & DN_MODIFY) {
> 		/* What does this mean on directories? */
> 		cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_LAST_WRITE |
> 			FILE_NOTIFY_CHANGE_SIZE;
> 	}
>-	if(fcntl_notify_flags & DN_CREATE) {
>-		cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_CREATION | 
>+	if (fcntl_notify_flags & DN_CREATE) {
>+		cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_CREATION |
> 			FILE_NOTIFY_CHANGE_LAST_WRITE;
> 	}
>-	if(fcntl_notify_flags & DN_DELETE) {
>+	if (fcntl_notify_flags & DN_DELETE) {
> 		cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_LAST_WRITE;
> 	}
>-	if(fcntl_notify_flags & DN_RENAME) {
>+	if (fcntl_notify_flags & DN_RENAME) {
> 		/* BB review this - checking various server behaviors */
>-		cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_DIR_NAME | 
>+		cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_DIR_NAME |
> 			FILE_NOTIFY_CHANGE_FILE_NAME;
> 	}
>-	if(fcntl_notify_flags & DN_ATTRIB) {
>-		cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_SECURITY | 
>+	if (fcntl_notify_flags & DN_ATTRIB) {
>+		cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_SECURITY |
> 			FILE_NOTIFY_CHANGE_ATTRIBUTES;
> 	}
>-/*	if(fcntl_notify_flags & DN_MULTISHOT) {
>+/*	if (fcntl_notify_flags & DN_MULTISHOT) {
> 		cifs_ntfy_flags |= ;
> 	} */ /* BB fixme - not sure how to handle this with CIFS yet */
> 
>-
> 	return cifs_ntfy_flags;
> }
> 
>-int cifs_dir_notify(struct file * file, unsigned long arg)
>+int cifs_dir_notify(struct file *file, unsigned long arg)
> {
> 	int xid;
> 	int rc = -EINVAL;
>@@ -78,31 +77,37 @@ int cifs_dir_notify(struct file * file, unsigned long arg)
> 	__u32 filter = FILE_NOTIFY_CHANGE_NAME | FILE_NOTIFY_CHANGE_ATTRIBUTES;
> 	__u16 netfid;
> 
>-
>-	if(experimEnabled == 0)
>+	if (experimEnabled == 0)
> 		return 0;
> 
> 	xid = GetXid();
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
> 	pTcon = cifs_sb->tcon;
> 
> 	full_path = build_path_from_dentry(file->f_dentry);
>+#else
>+	cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
>+	pTcon = cifs_sb->tcon;
>+
>+	full_path = build_path_from_dentry(file->f_path.dentry);
>+#endif
> 
>-	if(full_path == NULL) {
>+	if (full_path == NULL) {
> 		rc = -ENOMEM;
> 	} else {
>-		cFYI(1,("dir notify on file %s Arg 0x%lx",full_path,arg));
>-		rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, 
>+		cFYI(1, ("dir notify on file %s Arg 0x%lx", full_path, arg));
>+		rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
> 			GENERIC_READ | SYNCHRONIZE, 0 /* create options */,
>-			&netfid, &oplock,NULL, cifs_sb->local_nls,
>+			&netfid, &oplock, NULL, cifs_sb->local_nls,
> 			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
> 		/* BB fixme - add this handle to a notify handle list */
>-		if(rc) {
>-			cFYI(1,("Could not open directory for notify"));
>+		if (rc) {
>+			cFYI(1, ("Could not open directory for notify"));
> 		} else {
> 			filter = convert_to_cifs_notify_flags(arg);
>-			if(filter != 0) {
>-				rc = CIFSSMBNotify(xid, pTcon, 
>+			if (filter != 0) {
>+				rc = CIFSSMBNotify(xid, pTcon,
> 					0 /* no subdirs */, netfid,
> 					filter, file, arg & DN_MULTISHOT,
> 					cifs_sb->local_nls);
>@@ -113,10 +118,10 @@ int cifs_dir_notify(struct file * file, unsigned long arg)
> 			it would close automatically but may be a way
> 			to do it easily when inode freed or when
> 			notify info is cleared/changed */
>-			cFYI(1,("notify rc %d",rc));
>+			cFYI(1, ("notify rc %d", rc));
> 		}
> 	}
>-	
>+
> 	FreeXid(xid);
> 	return rc;
> }
>diff --git a/fs/cifs/file.c b/fs/cifs/file.c
>index 603cf48..b72bba1 100644
>--- a/fs/cifs/file.c
>+++ b/fs/cifs/file.c
>@@ -2,8 +2,8 @@
>  *   fs/cifs/file.c
>  *
>  *   vfs operations that deal with files
>- * 
>- *   Copyright (C) International Business Machines  Corp., 2002,2003
>+ *
>+ *   Copyright (C) International Business Machines  Corp., 2002,2007
>  *   Author(s): Steve French (sfrench@us.ibm.com)
>  *              Jeremy Allison (jra@samba.org)
>  *
>@@ -25,7 +25,6 @@
> #include <linux/stat.h>
> #include <linux/fcntl.h>
> #include <linux/pagemap.h>
>-#include <linux/smp_lock.h>
> #include <linux/delay.h>
> #include <asm/div64.h>
> #include "cifsfs.h"
>@@ -55,9 +54,13 @@ static inline struct cifsFileInfo *cifs_init_private(
> {
> 	memset(private_data, 0, sizeof(struct cifsFileInfo));
> 	private_data->netfid = netfid;
>-	private_data->pid = current->tgid;	
>+	private_data->pid = current->tgid;
> 	init_MUTEX(&private_data->fh_sem);
>-	init_MUTEX(&private_data->lock_sem);
>+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)
>+	mutex_init(&private_data->lock_mutex);
>+#else
>+	init_MUTEX(&private_data->lock_mutex);
>+#endif
> 	INIT_LIST_HEAD(&private_data->llist);
> 	private_data->pfile = file; /* needed for writepage */
> 	private_data->pInode = inode;
>@@ -67,7 +70,7 @@ static inline struct cifsFileInfo *cifs_init_private(
> 	does not tell us which handle the write is for so there can
> 	be a close (overlapping with write) of the filehandle that
> 	cifs_writepages chose to use */
>-	atomic_set(&private_data->wrtPending,0); 
>+	atomic_set(&private_data->wrtPending, 0);
> 
> 	return private_data;
> }
>@@ -123,7 +126,7 @@ static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
> 	   in the list so we do not have to walk the
> 	   list to search for one in prepare_write */
> 	if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
>-		list_add_tail(&pCifsFile->flist, 
>+		list_add_tail(&pCifsFile->flist,
> 			      &pCifsInode->openFileList);
> 	} else {
> 		list_add(&pCifsFile->flist,
>@@ -140,15 +143,26 @@ static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
> 	/* 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) && 
>-			   (file->f_dentry->d_inode->i_size == 
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
>+	if (timespec_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"));
> 	} else {
> 		if (file->f_dentry->d_inode->i_mapping) {
>+#else
>+	if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
>+			   (file->f_path.dentry->d_inode->i_size ==
>+			    (loff_t)le64_to_cpu(buf->EndOfFile))) {
>+		cFYI(1, ("inode unchanged on server"));
>+	} else {
>+		if (file->f_path.dentry->d_inode->i_mapping) {
>+#endif
> 		/* BB no need to lock inode until after invalidate
> 		   since namei code should already have it locked? */
>-#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 15)
>+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 19)
>+			filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);		   
>+#elif 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);
>@@ -157,22 +171,39 @@ static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
> 		}
> 		cFYI(1, ("invalidating remote inode since open detected it "
> 			 "changed"));
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 		invalidate_remote_inode(file->f_dentry->d_inode);
>+#else			 
>+		invalidate_remote_inode(file->f_path.dentry->d_inode);
>+#endif
> 	}
> 
> client_can_cache:
>-	if (pTcon->ses->capabilities & CAP_UNIX)
>+	if (pTcon->unix_ext)
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 		rc = cifs_get_inode_info_unix(&file->f_dentry->d_inode,
>+#else	
>+		rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
>+#endif
> 			full_path, inode->i_sb, xid);
>-	else
>+
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 		rc = cifs_get_inode_info(&file->f_dentry->d_inode,
>+#else
>+		rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
>+#endif
> 			full_path, buf, inode->i_sb, xid);
> 
> 	if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
> 		pCifsInode->clientCanCacheAll = TRUE;
> 		pCifsInode->clientCanCacheRead = TRUE;
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 		cFYI(1, ("Exclusive Oplock granted on inode %p",
> 			 file->f_dentry->d_inode));
>+#else
>+		cFYI(1, ("Exclusive Oplock granted on inode %p",
>+			 file->f_path.dentry->d_inode));
>+#endif
> 	} else if ((*oplock & 0xF) == OPLOCK_READ)
> 		pCifsInode->clientCanCacheRead = TRUE;
> 
>@@ -201,7 +232,11 @@ int cifs_open(struct inode *inode, struct file *file)
> 
> 	if (file->f_flags & O_CREAT) {
> 		/* search inode for this file and fill in file->private_data */
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 		pCifsInode = CIFS_I(file->f_dentry->d_inode);
>+#else
>+		pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
>+#endif
> 		read_lock(&GlobalSMBSeslock);
> 		list_for_each(tmp, &pCifsInode->openFileList) {
> 			pCifsFile = list_entry(tmp, struct cifsFileInfo,
>@@ -212,7 +247,7 @@ int cifs_open(struct inode *inode, struct file *file)
> 
> 				/* needed for writepage */
> 				pCifsFile->pfile = file;
>-				
>+
> 				file->private_data = pCifsFile;
> 				break;
> 			}
>@@ -229,21 +264,25 @@ int cifs_open(struct inode *inode, struct file *file)
> 		}
> 	}
> 
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	full_path = build_path_from_dentry(file->f_dentry);
>+#else
>+	full_path = build_path_from_dentry(file->f_path.dentry);
>+#endif
> 	if (full_path == NULL) {
> 		FreeXid(xid);
> 		return -ENOMEM;
> 	}
> 
>-	cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
>+	cFYI(1, ("inode = 0x%p file flags are 0x%x for %s",
> 		 inode, file->f_flags, full_path));
> 	desiredAccess = cifs_convert_flags(file->f_flags);
> 
> /*********************************************************************
>  *  open flag mapping table:
>- *  
>+ *
>  *	POSIX Flag            CIFS Disposition
>- *	----------            ---------------- 
>+ *	----------            ----------------
>  *	O_CREAT               FILE_OPEN_IF
>  *	O_CREAT | O_EXCL      FILE_CREATE
>  *	O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
>@@ -251,12 +290,12 @@ int cifs_open(struct inode *inode, struct file *file)
>  *	none of the above     FILE_OPEN
>  *
>  *	Note that there is not a direct match between disposition
>- *	FILE_SUPERSEDE (ie create whether or not file exists although 
>+ *	FILE_SUPERSEDE (ie create whether or not file exists although
>  *	O_CREAT | O_TRUNC is similar but truncates the existing
>  *	file rather than creating a new file as FILE_SUPERSEDE does
>  *	(which uses the attributes / metadata passed in on open call)
>  *?
>- *?  O_SYNC is a reasonable match to CIFS writethrough flag  
>+ *?  O_SYNC is a reasonable match to CIFS writethrough flag
>  *?  and the read write flags match reasonably.  O_LARGEFILE
>  *?  is irrelevant because largefile support is always used
>  *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
>@@ -276,8 +315,8 @@ int cifs_open(struct inode *inode, struct file *file)
> 	   and calling get_inode_info with returned buf (at least helps
> 	   non-Unix server case) */
> 
>-	/* BB we can not do this if this is the second open of a file 
>-	   and the first handle has writebehind data, we might be 
>+	/* BB we can not do this if this is the second open of a file
>+	   and the first handle has writebehind data, we might be
> 	   able to simply do a filemap_fdatawrite/filemap_fdatawait first */
> 	buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
> 	if (!buf) {
>@@ -286,7 +325,7 @@ int cifs_open(struct inode *inode, struct file *file)
> 	}
> 
> 	if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
>-		rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, 
>+		rc = CIFSSMBOpen(xid, pTcon, full_path, disposition,
> 			 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
> 			 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
> 				 & CIFS_MOUNT_MAP_SPECIAL_CHR);
>@@ -314,7 +353,11 @@ int cifs_open(struct inode *inode, struct file *file)
> 	write_lock(&GlobalSMBSeslock);
> 	list_add(&pCifsFile->tlist, &pTcon->openFileList);
> 
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	pCifsInode = CIFS_I(file->f_dentry->d_inode);
>+#else
>+	pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
>+#endif
> 	if (pCifsInode) {
> 		rc = cifs_open_inode_helper(inode, file, pCifsInode,
> 					    pCifsFile, pTcon,
>@@ -323,15 +366,15 @@ int cifs_open(struct inode *inode, struct file *file)
> 		write_unlock(&GlobalSMBSeslock);
> 	}
> 
>-	if (oplock & CIFS_CREATE_ACTION) {           
>+	if (oplock & CIFS_CREATE_ACTION) {
> 		/* time to set mode which we can not set earlier due to
> 		   problems creating new read-only files */
>-		if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) {
>+		if (pTcon->unix_ext) {
> 			CIFSSMBUnixSetPerms(xid, pTcon, full_path,
> 					    inode->i_mode,
> 					    (__u64)-1, (__u64)-1, 0 /* dev */,
> 					    cifs_sb->local_nls,
>-					    cifs_sb->mnt_cifs_flags & 
>+					    cifs_sb->mnt_cifs_flags &
> 						CIFS_MOUNT_MAP_SPECIAL_CHR);
> 		} else {
> 			/* BB implement via Windows security descriptors eg
>@@ -360,8 +403,7 @@ static int cifs_relock_file(struct cifsFileInfo *cifsFile)
> 	return rc;
> }
> 
>-static int cifs_reopen_file(struct inode *inode, struct file *file, 
>-	int can_flush)
>+static int cifs_reopen_file(struct file *file, int can_flush)
> {
> 	int rc = -EACCES;
> 	int xid, oplock;
>@@ -369,13 +411,12 @@ static int cifs_reopen_file(struct inode *inode, struct file *file,
> 	struct cifsTconInfo *pTcon;
> 	struct cifsFileInfo *pCifsFile;
> 	struct cifsInodeInfo *pCifsInode;
>+	struct inode *inode;
> 	char *full_path = NULL;
> 	int desiredAccess;
> 	int disposition = FILE_OPEN;
> 	__u16 netfid;
> 
>-	if (inode == NULL)
>-		return -EBADF;
> 	if (file->private_data) {
> 		pCifsFile = (struct cifsFileInfo *)file->private_data;
> 	} else
>@@ -389,27 +430,65 @@ static int cifs_reopen_file(struct inode *inode, struct file *file,
> 		return 0;
> 	}
> 
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	if (file->f_dentry == NULL) {
>-		up(&pCifsFile->fh_sem);
>-		cFYI(1, ("failed file reopen, no valid name if dentry freed"));
>-		FreeXid(xid);
>-		return -EBADF;
>+		cERROR(1, ("no valid name if dentry freed"));
>+		dump_stack();
>+		rc = -EBADF;
>+		goto reopen_error_exit;
>+	}
>+
>+	inode = file->f_dentry->d_inode;
>+	if (inode == NULL) {
>+		cERROR(1, ("inode not valid"));
>+		dump_stack();
>+		rc = -EBADF;
>+		goto reopen_error_exit;
> 	}
>+
> 	cifs_sb = CIFS_SB(inode->i_sb);
> 	pTcon = cifs_sb->tcon;
>+
> /* can not grab rename sem here because various ops, including
>    those that already have the rename sem can end up causing writepage
>    to get called and if the server was down that means we end up here,
>    and we can never tell if the caller already has the rename_sem */
> 	full_path = build_path_from_dentry(file->f_dentry);
>+#else
>+	if (file->f_path.dentry == NULL) {
>+		cERROR(1, ("no valid name if dentry freed"));
>+		dump_stack();
>+		rc = -EBADF;
>+		goto reopen_error_exit;
>+	}
>+
>+	inode = file->f_path.dentry->d_inode;
>+	if (inode == NULL) {
>+		cERROR(1, ("inode not valid"));
>+		dump_stack();
>+		rc = -EBADF;
>+		goto reopen_error_exit;
>+	}
>+
>+	cifs_sb = CIFS_SB(inode->i_sb);
>+	pTcon = cifs_sb->tcon;
>+
>+/* can not grab rename sem here because various ops, including
>+   those that already have the rename sem can end up causing writepage
>+   to get called and if the server was down that means we end up here,
>+   and we can never tell if the caller already has the rename_sem */
>+	full_path = build_path_from_dentry(file->f_path.dentry);
>+#endif
> 	if (full_path == NULL) {
>+		rc = -ENOMEM;
>+reopen_error_exit:
> 		up(&pCifsFile->fh_sem);
> 		FreeXid(xid);
>-		return -ENOMEM;
>+		return rc;
> 	}
> 
>-	cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
>-		 inode, file->f_flags,full_path));
>+	cFYI(1, ("inode = 0x%p file flags 0x%x for %s",
>+		 inode, file->f_flags, full_path));
> 	desiredAccess = cifs_convert_flags(file->f_flags);
> 
> 	if (oplockEnabled)
>@@ -418,21 +497,14 @@ static int cifs_reopen_file(struct inode *inode, struct file *file,
> 		oplock = FALSE;
> 
> 	/* Can not refresh inode by passing in file_info buf to be returned
>-	   by SMBOpen and then calling get_inode_info with returned buf 
>-	   since file might have write behind data that needs to be flushed 
>+	   by SMBOpen and then calling get_inode_info with returned buf
>+	   since file might have write behind data that needs to be flushed
> 	   and server version of file size can be stale. If we knew for sure
> 	   that inode was not dirty locally we could do this */
> 
>-/*	buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
>-	if (buf == 0) {
>-		up(&pCifsFile->fh_sem);
>-		kfree(full_path);
>-		FreeXid(xid);
>-		return -ENOMEM;
>-	} */
> 	rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
> 			 CREATE_NOT_DIR, &netfid, &oplock, NULL,
>-			 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags & 
>+			 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
> 				CIFS_MOUNT_MAP_SPECIAL_CHR);
> 	if (rc) {
> 		up(&pCifsFile->fh_sem);
>@@ -451,12 +523,11 @@ static int cifs_reopen_file(struct inode *inode, struct file *file,
> 				filemap_fdatawrite(inode->i_mapping);
> 				filemap_fdatawait(inode->i_mapping);
> #endif
>-
> 			/* temporarily disable caching while we
> 			   go to server to get inode info */
> 				pCifsInode->clientCanCacheAll = FALSE;
> 				pCifsInode->clientCanCacheRead = FALSE;
>-				if (pTcon->ses->capabilities & CAP_UNIX)
>+				if (pTcon->unix_ext)
> 					rc = cifs_get_inode_info_unix(&inode,
> 						full_path, inode->i_sb, xid);
> 				else
>@@ -472,8 +543,13 @@ static int cifs_reopen_file(struct inode *inode, struct file *file,
> 			if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
> 				pCifsInode->clientCanCacheAll = TRUE;
> 				pCifsInode->clientCanCacheRead = TRUE;
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
>+				cFYI(1, ("Exclusive Oplock granted on inode %p",
>+					file->f_dentry->d_inode));
>+#else
> 				cFYI(1, ("Exclusive Oplock granted on inode %p",
>-					 file->f_dentry->d_inode));
>+					 file->f_path.dentry->d_inode));
>+#endif
> 			} else if ((oplock & 0xF) == OPLOCK_READ) {
> 				pCifsInode->clientCanCacheRead = TRUE;
> 				pCifsInode->clientCanCacheAll = FALSE;
>@@ -493,7 +569,7 @@ static int cifs_reopen_file(struct inode *inode, struct file *file,
> int cifs_close(struct inode *inode, struct file *file)
> {
> 	int rc = 0;
>-	int xid;
>+	int xid, timeout;
> 	struct cifs_sb_info *cifs_sb;
> 	struct cifsTconInfo *pTcon;
> 	struct cifsFileInfo *pSMBFile =
>@@ -511,24 +587,25 @@ int cifs_close(struct inode *inode, struct file *file)
> 			/* no sense reconnecting to close a file that is
> 			   already closed */
> 			if (pTcon->tidStatus != CifsNeedReconnect) {
>-				int timeout = 2;
>-				while((atomic_read(&pSMBFile->wrtPending) != 0)
>-					 && (timeout < 1000) ) {
>+				timeout = 2;
>+				while ((atomic_read(&pSMBFile->wrtPending) != 0)
>+					&& (timeout <= 2048)) {
> 					/* Give write a better chance to get to
> 					server ahead of the close.  We do not
> 					want to add a wait_q here as it would
> 					increase the memory utilization as
> 					the struct would be in each open file,
>-					but this should give enough time to 
>+					but this should give enough time to
> 					clear the socket */
> #ifdef CONFIG_CIFS_DEBUG2
>-					cFYI(1,("close delay, write pending"));
>+					cFYI(1, ("close delay, write pending"));
> #endif /* DEBUG2 */
> 					msleep(timeout);
> 					timeout *= 4;
> 				}
>-				if(atomic_read(&pSMBFile->wrtPending))
>-					cERROR(1,("close with pending writes"));
>+				if (atomic_read(&pSMBFile->wrtPending))
>+					cERROR(1,
>+						("close with pending writes"));
> 				rc = CIFSSMBClose(xid, pTcon,
> 						  pSMBFile->netfid);
> 			}
>@@ -536,23 +613,41 @@ int cifs_close(struct inode *inode, struct file *file)
> 
> 		/* Delete any outstanding lock records.
> 		   We'll lose them when the file is closed anyway. */
>-		down(&pSMBFile->lock_sem);
>+		mutex_lock(&pSMBFile->lock_mutex);
> 		list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
> 			list_del(&li->llist);
> 			kfree(li);
> 		}
>-		up(&pSMBFile->lock_sem);
>+		mutex_unlock(&pSMBFile->lock_mutex);
> 
> 		write_lock(&GlobalSMBSeslock);
> 		list_del(&pSMBFile->flist);
> 		list_del(&pSMBFile->tlist);
> 		write_unlock(&GlobalSMBSeslock);
>+		timeout = 10;
>+		/* We waited above to give the SMBWrite a chance to issue
>+		   on the wire (so we do not get SMBWrite returning EBADF
>+		   if writepages is racing with close.  Note that writepages
>+		   does not specify a file handle, so it is possible for a file
>+		   to be opened twice, and the application close the "wrong"
>+		   file handle - in these cases we delay long enough to allow
>+		   the SMBWrite to get on the wire before the SMB Close.
>+		   We allow total wait here over 45 seconds, more than
>+		   oplock break time, and more than enough to allow any write
>+		   to complete on the server, or to time out on the client */
>+		while ((atomic_read(&pSMBFile->wrtPending) != 0)
>+				&& (timeout <= 50000)) {
>+			cERROR(1, ("writes pending, delay free of handle"));
>+			msleep(timeout);
>+			timeout *= 8;
>+		}
> 		kfree(pSMBFile->search_resume_name);
> 		kfree(file->private_data);
> 		file->private_data = NULL;
> 	} else
> 		rc = -EBADF;
> 
>+	read_lock(&GlobalSMBSeslock);
> 	if (list_empty(&(CIFS_I(inode)->openFileList))) {
> 		cFYI(1, ("closing last open instance for inode %p", inode));
> 		/* if the file is not open we do not know if we can cache info
>@@ -560,7 +655,8 @@ int cifs_close(struct inode *inode, struct file *file)
> 		CIFS_I(inode)->clientCanCacheRead = FALSE;
> 		CIFS_I(inode)->clientCanCacheAll  = FALSE;
> 	}
>-	if ((rc ==0) && CIFS_I(inode)->write_behind_rc)
>+	read_unlock(&GlobalSMBSeslock);
>+	if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
> 		rc = CIFS_I(inode)->write_behind_rc;
> 	FreeXid(xid);
> 	return rc;
>@@ -580,7 +676,12 @@ int cifs_closedir(struct inode *inode, struct file *file)
> 
> 	if (pCFileStruct) {
> 		struct cifsTconInfo *pTcon;
>-		struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_dentry->d_sb);
>+		struct cifs_sb_info *cifs_sb =
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
>+			CIFS_SB(file->f_dentry->d_sb);
>+#else
>+			CIFS_SB(file->f_path.dentry->d_sb);
>+#endif
> 
> 		pTcon = cifs_sb->tcon;
> 
>@@ -598,7 +699,7 @@ int cifs_closedir(struct inode *inode, struct file *file)
> 		if (ptmp) {
> 			cFYI(1, ("closedir free smb buf in srch struct"));
> 			pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
>-			if(pCFileStruct->srch_inf.smallBuf)
>+			if (pCFileStruct->srch_inf.smallBuf)
> 				cifs_small_buf_release(ptmp);
> 			else
> 				cifs_buf_release(ptmp);
>@@ -620,15 +721,16 @@ int cifs_closedir(struct inode *inode, struct file *file)
> static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
> 				__u64 offset, __u8 lockType)
> {
>-	struct cifsLockInfo *li = kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
>+	struct cifsLockInfo *li =
>+		kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
> 	if (li == NULL)
> 		return -ENOMEM;
> 	li->offset = offset;
> 	li->length = len;
> 	li->type = lockType;
>-	down(&fid->lock_sem);
>+	mutex_lock(&fid->lock_mutex);
> 	list_add(&li->llist, &fid->llist);
>-	up(&fid->lock_sem);
>+	mutex_unlock(&fid->lock_mutex);
> 	return 0;
> }
> 
>@@ -651,8 +753,8 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
> 
> 	cFYI(1, ("Lock parm: 0x%x flockflags: "
> 		 "0x%x flocktype: 0x%x start: %lld end: %lld",
>-	        cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
>-	        pfLock->fl_end));
>+		cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
>+		pfLock->fl_end));
> 
> 	if (pfLock->fl_flags & FL_POSIX)
> 		cFYI(1, ("Posix"));
>@@ -667,7 +769,7 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
> 			 "not implemented yet"));
> 	if (pfLock->fl_flags & FL_LEASE)
> 		cFYI(1, ("Lease on file - not implemented yet"));
>-	if (pfLock->fl_flags & 
>+	if (pfLock->fl_flags &
> 	    (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
> 		cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
> 
>@@ -693,7 +795,11 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
> 	} else
> 		cFYI(1, ("Unknown type of lock"));
> 
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
>+#else
>+	cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
>+#endif
> 	pTcon = cifs_sb->tcon;
> 
> 	if (file->private_data == NULL) {
>@@ -709,9 +815,9 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
> 	account for negative length which we can not accept over the
> 	wire */
> 	if (IS_GETLK(cmd)) {
>-		if(posix_locking) {
>+		if (posix_locking) {
> 			int posix_lock_type;
>-			if(lockType & LOCKING_ANDX_SHARED_LOCK)
>+			if (lockType & LOCKING_ANDX_SHARED_LOCK)
> 				posix_lock_type = CIFS_RDLCK;
> 			else
> 				posix_lock_type = CIFS_WRLCK;
>@@ -726,7 +832,7 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
> 		rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
> 				 0, 1, lockType, 0 /* wait flag */ );
> 		if (rc == 0) {
>-			rc = CIFSSMBLock(xid, pTcon, netfid, length, 
>+			rc = CIFSSMBLock(xid, pTcon, netfid, length,
> 					 pfLock->fl_start, 1 /* numUnlock */ ,
> 					 0 /* numLock */ , lockType,
> 					 0 /* wait flag */ );
>@@ -755,22 +861,24 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
> 
> 	if (posix_locking) {
> 		int posix_lock_type;
>-		if(lockType & LOCKING_ANDX_SHARED_LOCK)
>+		if (lockType & LOCKING_ANDX_SHARED_LOCK)
> 			posix_lock_type = CIFS_RDLCK;
> 		else
> 			posix_lock_type = CIFS_WRLCK;
>-		
>-		if(numUnlock == 1)
>+
>+		if (numUnlock == 1)
> 			posix_lock_type = CIFS_UNLCK;
> 
> 		rc = CIFSSMBPosixLock(xid, pTcon, netfid, 0 /* set */,
> 				      length, pfLock,
> 				      posix_lock_type, wait_flag);
> 	} else {
>-		struct cifsFileInfo *fid = (struct cifsFileInfo *)file->private_data;
>+		struct cifsFileInfo *fid =
>+			(struct cifsFileInfo *)file->private_data;
> 
> 		if (numLock) {
>-			rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
>+			rc = CIFSSMBLock(xid, pTcon, netfid, length,
>+					pfLock->fl_start,
> 					0, numLock, lockType, wait_flag);
> 
> 			if (rc == 0) {
>@@ -785,11 +893,13 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
> 			struct cifsLockInfo *li, *tmp;
> 
> 			rc = 0;
>-			down(&fid->lock_sem);
>+			mutex_lock(&fid->lock_mutex);
> 			list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
> 				if (pfLock->fl_start <= li->offset &&
>-						length >= li->length) {
>-					stored_rc = CIFSSMBLock(xid, pTcon, netfid,
>+						(pfLock->fl_start + length) >=
>+						(li->offset + li->length)) {
>+					stored_rc = CIFSSMBLock(xid, pTcon,
>+							netfid,
> 							li->length, li->offset,
> 							1, 0, li->type, FALSE);
> 					if (stored_rc)
>@@ -799,7 +909,7 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
> 					kfree(li);
> 				}
> 			}
>-			up(&fid->lock_sem);
>+			mutex_unlock(&fid->lock_mutex);
> 		}
> 	}
> 
>@@ -822,31 +932,29 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
> 	int xid, long_op;
> 	struct cifsFileInfo *open_file;
> 
>-	if (file->f_dentry == NULL)
>-		return -EBADF;
>-
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
>-	if (cifs_sb == NULL)
>-		return -EBADF;
>+#else
>+	cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
>+#endif
> 
> 	pTcon = cifs_sb->tcon;
> 
> 	/* cFYI(1,
> 	   (" write %d bytes to offset %lld of %s", write_size,
>-	   *poffset, file->f_dentry->d_name.name)); */
>+	   *poffset, file->f_path.dentry->d_name.name)); */
> 
> 	if (file->private_data == NULL)
> 		return -EBADF;
>-	else
>-		open_file = (struct cifsFileInfo *) file->private_data;
>-	
>+	open_file = (struct cifsFileInfo *) file->private_data;
>+
> 	xid = GetXid();
>-	if (file->f_dentry->d_inode == NULL) {
>-		FreeXid(xid);
>-		return -EBADF;
>-	}
> 
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	if (*poffset > file->f_dentry->d_inode->i_size)
>+#else
>+	if (*poffset > file->f_path.dentry->d_inode->i_size)
>+#endif
> 		long_op = 2; /* writes past end of file can take a long time */
> 	else
> 		long_op = 1;
>@@ -862,7 +970,7 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
> 			   and blocked, and the file has been freed on us while
> 			   we blocked so return what we managed to write */
> 				return total_written;
>-			} 
>+			}
> 			if (open_file->closePend) {
> 				FreeXid(xid);
> 				if (total_written)
>@@ -871,17 +979,11 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
> 					return -EBADF;
> 			}
> 			if (open_file->invalidHandle) {
>-				if ((file->f_dentry == NULL) ||
>-				    (file->f_dentry->d_inode == NULL)) {
>-					FreeXid(xid);
>-					return total_written;
>-				}
> 				/* we could deadlock if we called
> 				   filemap_fdatawait from here so tell
> 				   reopen_file not to flush data to server
> 				   now */
>-				rc = cifs_reopen_file(file->f_dentry->d_inode,
>-					file, FALSE);
>+				rc = cifs_reopen_file(file, FALSE);
> 				if (rc != 0)
> 					break;
> 			}
>@@ -909,18 +1011,35 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
> 	cifs_stats_bytes_written(pTcon, total_written);
> 
> 	/* since the write may have blocked check these pointers again */
>-	if (file->f_dentry) {
>-		if (file->f_dentry->d_inode) {
>-			struct inode *inode = file->f_dentry->d_inode;
>-			inode->i_ctime = inode->i_mtime =
>-				current_fs_time(inode->i_sb);
>-			if (total_written > 0) {
>-				if (*poffset > file->f_dentry->d_inode->i_size)
>-					i_size_write(file->f_dentry->d_inode,
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
>+	if ((file->f_dentry) && (file->f_dentry->d_inode)) {
>+		struct inode *inode = file->f_dentry->d_inode;
>+/* Do not update local mtime - server will set its actual value on write
>+ *		inode->i_ctime = inode->i_mtime =
>+ * 			current_fs_time(inode->i_sb);*/
>+		if (total_written > 0) {
>+			spin_lock(&inode->i_lock);
>+			if (*poffset > file->f_dentry->d_inode->i_size)
>+				i_size_write(file->f_dentry->d_inode,
> 					*poffset);
>-			}
>-			mark_inode_dirty_sync(file->f_dentry->d_inode);
>+			spin_unlock(&inode->i_lock);
>+		}
>+		mark_inode_dirty_sync(file->f_dentry->d_inode);
>+#else
>+	if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
>+		struct inode *inode = file->f_path.dentry->d_inode;
>+/* Do not update local mtime - server will set its actual value on write
>+ *		inode->i_ctime = inode->i_mtime =
>+ * 			current_fs_time(inode->i_sb);*/
>+		if (total_written > 0) {
>+			spin_lock(&inode->i_lock);
>+			if (*poffset > file->f_path.dentry->d_inode->i_size)
>+				i_size_write(file->f_path.dentry->d_inode,
>+					*poffset);
>+			spin_unlock(&inode->i_lock);
> 		}
>+		mark_inode_dirty_sync(file->f_path.dentry->d_inode);
>+#endif
> 	}
> 	FreeXid(xid);
> 	return total_written;
>@@ -937,30 +1056,37 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
> 	int xid, long_op;
> 	struct cifsFileInfo *open_file;
> 
>-	if (file->f_dentry == NULL)
>-		return -EBADF;
>-
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
>-	if (cifs_sb == NULL)
>-		return -EBADF;
> 
> 	pTcon = cifs_sb->tcon;
> 
>-	cFYI(1,("write %zd bytes to offset %lld of %s", write_size,
>+	cFYI(1, ("write %zd bytes to offset %lld of %s", write_size,
> 	   *poffset, file->f_dentry->d_name.name));
> 
> 	if (file->private_data == NULL)
> 		return -EBADF;
>-	else
>-		open_file = (struct cifsFileInfo *)file->private_data;
>-	
>+	open_file = (struct cifsFileInfo *)file->private_data;
>+
> 	xid = GetXid();
>-	if (file->f_dentry->d_inode == NULL) {
>-		FreeXid(xid);
>-		return -EBADF;
>-	}
> 
> 	if (*poffset > file->f_dentry->d_inode->i_size)
>+#else
>+	cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
>+
>+	pTcon = cifs_sb->tcon;
>+
>+	cFYI(1, ("write %zd bytes to offset %lld of %s", write_size,
>+	   *poffset, file->f_path.dentry->d_name.name));
>+
>+	if (file->private_data == NULL)
>+		return -EBADF;
>+	open_file = (struct cifsFileInfo *)file->private_data;
>+
>+	xid = GetXid();
>+
>+	if (*poffset > file->f_path.dentry->d_inode->i_size)
>+#endif	
> 		long_op = 2; /* writes past end of file can take a long time */
> 	else
> 		long_op = 1;
>@@ -974,10 +1100,10 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
> 				FreeXid(xid);
> 			/* if we have gotten here we have written some data
> 			   and blocked, and the file has been freed on us
>-			   while we blocked so return what we managed to 
>+			   while we blocked so return what we managed to
> 			   write */
> 				return total_written;
>-			} 
>+			}
> 			if (open_file->closePend) {
> 				FreeXid(xid);
> 				if (total_written)
>@@ -986,22 +1112,16 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
> 					return -EBADF;
> 			}
> 			if (open_file->invalidHandle) {
>-				if ((file->f_dentry == NULL) ||
>-				   (file->f_dentry->d_inode == NULL)) {
>-					FreeXid(xid);
>-					return total_written;
>-				}
> 				/* we could deadlock if we called
> 				   filemap_fdatawait from here so tell
>-				   reopen_file not to flush data to 
>+				   reopen_file not to flush data to
> 				   server now */
>-				rc = cifs_reopen_file(file->f_dentry->d_inode,
>-					file, FALSE);
>+				rc = cifs_reopen_file(file, FALSE);
> 				if (rc != 0)
> 					break;
> 			}
>-			if(experimEnabled || (pTcon->ses->server &&
>-				((pTcon->ses->server->secMode & 
>+			if (experimEnabled || (pTcon->ses->server &&
>+				((pTcon->ses->server->secMode &
> 				(SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
> 				== 0))) {
> 				struct kvec iov[2];
>@@ -1035,25 +1155,40 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
> 			}
> 		} else
> 			*poffset += bytes_written;
>-		long_op = FALSE; /* subsequent writes fast - 
>+		long_op = FALSE; /* subsequent writes fast -
> 				    15 seconds is plenty */
> 	}
> 
> 	cifs_stats_bytes_written(pTcon, total_written);
> 
> 	/* since the write may have blocked check these pointers again */
>-	if (file->f_dentry) {
>-		if (file->f_dentry->d_inode) {
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
>+	if ((file->f_dentry) && (file->f_dentry->d_inode)) {
> /*BB We could make this contingent on superblock ATIME flag too */
>-/*			file->f_dentry->d_inode->i_ctime = 
>-			file->f_dentry->d_inode->i_mtime = CURRENT_TIME;*/
>-			if (total_written > 0) {
>-				if (*poffset > file->f_dentry->d_inode->i_size)
>-					i_size_write(file->f_dentry->d_inode, 
>-						     *poffset);
>-			}
>-			mark_inode_dirty_sync(file->f_dentry->d_inode);
>+/*		file->f_dentry->d_inode->i_ctime =
>+		file->f_dentry->d_inode->i_mtime = CURRENT_TIME;*/
>+		if (total_written > 0) {
>+			spin_lock(&file->f_dentry->d_inode->i_lock);
>+			if (*poffset > file->f_dentry->d_inode->i_size)
>+				i_size_write(file->f_dentry->d_inode,
>+					     *poffset);
>+			spin_unlock(&file->f_dentry->d_inode->i_lock);
>+		}
>+		mark_inode_dirty_sync(file->f_dentry->d_inode);
>+#else
>+	if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
>+/*BB We could make this contingent on superblock ATIME flag too */
>+/*		file->f_path.dentry->d_inode->i_ctime =
>+		file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
>+		if (total_written > 0) {
>+			spin_lock(&file->f_path.dentry->d_inode->i_lock);
>+			if (*poffset > file->f_path.dentry->d_inode->i_size)
>+				i_size_write(file->f_path.dentry->d_inode,
>+					     *poffset);
>+			spin_unlock(&file->f_path.dentry->d_inode->i_lock);
> 		}
>+		mark_inode_dirty_sync(file->f_path.dentry->d_inode);
>+#endif
> 	}
> 	FreeXid(xid);
> 	return total_written;
>@@ -1068,8 +1203,8 @@ struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
> 	the VFS or MM) should not happen but we had reports of on oops (due to
> 	it being zero) during stress testcases so we need to check for it */
> 
>-	if(cifs_inode == NULL) {
>-		cERROR(1,("Null inode passed to cifs_writeable_file"));
>+	if (cifs_inode == NULL) {
>+		cERROR(1, ("Null inode passed to cifs_writeable_file"));
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 4, 19)
> 		dump_stack();
> #endif
>@@ -1085,26 +1220,25 @@ struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
> 		     (open_file->pfile->f_flags & O_WRONLY))) {
> 			atomic_inc(&open_file->wrtPending);
> 			read_unlock(&GlobalSMBSeslock);
>-			if((open_file->invalidHandle) && 
>-			   (!open_file->closePend) /* BB fixme -since the second clause can not be true remove it BB */) {
>-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0)
>-				rc = cifs_reopen_file(open_file->pfile->f_dentry->d_inode,
>-#else
>-				rc = cifs_reopen_file(&cifs_inode->vfs_inode,
>-#endif
>-						      open_file->pfile, FALSE);
>+			if (open_file->invalidHandle) {
>+				rc = cifs_reopen_file(open_file->pfile, FALSE);
> 				/* if it fails, try another handle - might be */
> 				/* dangerous to hold up writepages with retry */
>-				if(rc) {
>-					cFYI(1,("failed on reopen file in wp"));
>+				if (rc) {
>+					cFYI(1, ("wp failed on reopen file"));
> 					read_lock(&GlobalSMBSeslock);
> 					/* can not use this handle, no write
> 					pending on this one after all */
>-					atomic_dec
>-					     (&open_file->wrtPending);
>+					atomic_dec(&open_file->wrtPending);
> 					continue;
>+
> 				}
> 			}
>+			if (open_file->closePend) {
>+				read_lock(&GlobalSMBSeslock);
>+				atomic_dec(&open_file->wrtPending);
>+				continue;
>+			}
> 			return open_file;
> 		}
> 	}
>@@ -1148,7 +1282,7 @@ static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
> 
> 	/* check to make sure that we are not extending the file */
> 	if (mapping->host->i_size - offset < (loff_t)to)
>-		to = (unsigned)(mapping->host->i_size - offset); 
>+		to = (unsigned)(mapping->host->i_size - offset);
> 
> 	open_file = find_writable_file(CIFS_I(mapping->host));
> 	if (open_file) {
>@@ -1172,7 +1306,6 @@ static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
> 	return rc;
> }
> 
>-
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 14)
> static int cifs_writepages(struct address_space *mapping,
> 			   struct writeback_control *wbc)
>@@ -1182,14 +1315,14 @@ static int cifs_writepages(struct address_space *mapping,
> 	unsigned int bytes_written;
> 	struct cifs_sb_info *cifs_sb;
> 	int done = 0;
>-	pgoff_t end = -1;
>+	pgoff_t end;
> 	pgoff_t index;
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)
> 	int range_whole = 0;
> #else		
> 	int is_range = 0;
>-#endif /* 2.6.17 */	
>-	struct kvec * iov;
>+#endif /* 2.6.17 */
>+	struct kvec *iov;
> 	int len;
> 	int n_iov = 0;
> 	pgoff_t next;
>@@ -1203,7 +1336,7 @@ static int cifs_writepages(struct address_space *mapping,
> 	int xid;
> 
> 	cifs_sb = CIFS_SB(mapping->host->i_sb);
>-	
>+
> 	/*
> 	 * If wsize is smaller that the page cache size, default to writing
> 	 * one page at a time via cifs_writepage
>@@ -1211,14 +1344,14 @@ static int cifs_writepages(struct address_space *mapping,
> 	if (cifs_sb->wsize < PAGE_CACHE_SIZE)
> 		return generic_writepages(mapping, wbc);
> 
>-	if((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
>-		if(cifs_sb->tcon->ses->server->secMode &
>-                          (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
>-			if(!experimEnabled) 
>+	if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
>+		if (cifs_sb->tcon->ses->server->secMode &
>+				(SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
>+			if (!experimEnabled)
> 				return generic_writepages(mapping, wbc);
> 
> 	iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
>-	if(iov == NULL)
>+	if (iov == NULL)
> 		return generic_writepages(mapping, wbc);
> 
> 
>@@ -1246,7 +1379,8 @@ static int cifs_writepages(struct address_space *mapping,
> 			range_whole = 1;
> 		scanned = 1;
> 	}
>-#else	
>+#else
>+	end = -1;
> 	if (wbc->sync_mode == WB_SYNC_NONE)
> 		index = mapping->writeback_index; /* Start from prev offset */
> 	else {
>@@ -1259,7 +1393,7 @@ static int cifs_writepages(struct address_space *mapping,
> 		is_range = 1;
> 		scanned = 1;
> 	}
>-#endif /* 2.6.17 */	
>+#endif /* 2.6.17 */
> retry:
> 	while (!done && (index <= end) &&
> 	       (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
>@@ -1370,7 +1504,7 @@ retry:
> 						   1);
> 				atomic_dec(&open_file->wrtPending);
> 				if (rc || bytes_written < bytes_to_write) {
>-					cERROR(1,("Write2 ret %d, written = %d",
>+					cERROR(1, ("Write2 ret %d, wrote %d",
> 						  rc, bytes_written));
> 					/* BB what if continued retry is
> 					   requested via mount flags? */
>@@ -1386,8 +1520,8 @@ retry:
> 				success rc but too little data written? */
> 				/* BB investigate retry logic on temporary
> 				server crash cases and how recovery works
>-				when page marked as error */ 
>-				if(rc)
>+				when page marked as error */
>+				if (rc)
> 					SetPageError(page);
> 				kunmap(page);
> 				unlock_page(page);
>@@ -1411,9 +1545,9 @@ retry:
> 	}
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)
> 	if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
>-#else	
>+#else
> 	if (!is_range)
>-#endif /* 2.6.17 */	
>+#endif /* 2.6.17 */
> 		mapping->writeback_index = index;
> 
> 	FreeXid(xid);
>@@ -1424,8 +1558,8 @@ retry:
> 
> #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
> static int cifs_writepage(struct page* page)
>-#else 
>-static int cifs_writepage(struct page* page, struct writeback_control *wbc)
>+#else
>+static int cifs_writepage(struct page *page, struct writeback_control *wbc)
> #endif
> {
> 	int rc = -EFAULT;
>@@ -1434,7 +1568,7 @@ static int cifs_writepage(struct page* page, struct writeback_control *wbc)
> 	xid = GetXid();
> /* BB add check for wbc flags */
> 	page_cache_get(page);
>-        if (!PageUptodate(page)) {
>+	if (!PageUptodate(page)) {
> 		cFYI(1, ("ppw - page not up to date"));
> 	}
> 
>@@ -1448,7 +1582,7 @@ static int cifs_writepage(struct page* page, struct writeback_control *wbc)
> 	 * Just unlocking the page will cause the radix tree tag-bits
> 	 * to fail to update with the state of the page correctly.
> 	 */
>-	set_page_writeback(page);		
>+	set_page_writeback(page);
> 	rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
> 	SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
> 	unlock_page(page);
>@@ -1468,37 +1602,11 @@ static int cifs_commit_write(struct file *file, struct page *page,
> 	char *page_data;
> 
> 	xid = GetXid();
>-	cFYI(1, ("commit write for page %p up to position %lld for %d", 
>+	cFYI(1, ("commit write for page %p up to position %lld for %d",
> 		 page, position, to));
> 	spin_lock(&inode->i_lock);
> 	if (position > inode->i_size) {
> 		i_size_write(inode, position);
>-		/* if (file->private_data == NULL) {
>-			rc = -EBADF;
>-		} else {
>-			open_file = (struct cifsFileInfo *)file->private_data;
>-			cifs_sb = CIFS_SB(inode->i_sb);
>-			rc = -EAGAIN;
>-			while (rc == -EAGAIN) {
>-				if ((open_file->invalidHandle) && 
>-				    (!open_file->closePend)) {
>-					rc = cifs_reopen_file(
>-						file->f_dentry->d_inode, file);
>-					if (rc != 0)
>-						break;
>-				}
>-				if (!open_file->closePend) {
>-					rc = CIFSSMBSetFileSize(xid,
>-						cifs_sb->tcon, position,
>-						open_file->netfid,
>-						open_file->pid, FALSE);
>-				} else {
>-					rc = -EBADF;
>-					break;
>-				}
>-			}
>-			cFYI(1, (" SetEOF (commit write) rc = %d", rc));
>-		} */
> 	}
> 	spin_unlock(&inode->i_lock);
> 	if (!PageUptodate(page)) {
>@@ -1522,7 +1630,7 @@ static int cifs_commit_write(struct file *file, struct page *page,
> 			rc = 0;
> 		/* else if (rc < 0) should we set writebehind rc? */
> 		kunmap(page);
>-	} else {	
>+	} else {
> 		set_page_dirty(page);
> 	}
> 
>@@ -1534,13 +1642,17 @@ int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
> {
> 	int xid;
> 	int rc = 0;
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	struct inode *inode = file->f_dentry->d_inode;
>+#else
>+	struct inode *inode = file->f_path.dentry->d_inode;
>+#endif
> 
> 	xid = GetXid();
> 
>-	cFYI(1, ("Sync file - name: %s datasync: 0x%x", 
>+	cFYI(1, ("Sync file - name: %s datasync: 0x%x",
> 		dentry->d_name.name, datasync));
>-	
>+
> 	rc = filemap_fdatawrite(inode->i_mapping);
> 	if (rc == 0)
> 		CIFS_I(inode)->write_behind_rc = 0;
>@@ -1548,7 +1660,7 @@ int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
> 	return rc;
> }
> 
>-/* static int cifs_sync_page(struct page *page)
>+/* static void cifs_sync_page(struct page *page)
> {
> 	struct address_space *mapping;
> 	struct inode *inode;
>@@ -1562,16 +1674,18 @@ int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
> 		return 0;
> 	inode = mapping->host;
> 	if (!inode)
>-		return 0; */
>+		return; */
> 
>-/*	fill in rpages then 
>+/*	fill in rpages then
> 	result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
> 
> /*	cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
> 
>+#if 0
> 	if (rc < 0)
> 		return rc;
> 	return 0;
>+#endif
> } */
> 
> /*
>@@ -1584,7 +1698,11 @@ int cifs_flush(struct file *file, fl_owner_t id)
> int cifs_flush(struct file *file)
> #endif /* 2.6.17 */
> {
>-	struct inode * inode = file->f_dentry->d_inode;
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
>+	struct inode *inode = file->f_dentry->d_inode;
>+#else
>+	struct inode *inode = file->f_path.dentry->d_inode;
>+#endif
> 	int rc = 0;
> 
> 	/* Rather than do the steps manually:
>@@ -1599,8 +1717,8 @@ int cifs_flush(struct file *file)
> 	rc = filemap_fdatawrite(inode->i_mapping);
> 	if (!rc) /* reset wb rc if we were able to write out dirty pages */
> 		CIFS_I(inode)->write_behind_rc = 0;
>-		
>-	cFYI(1, ("Flush inode %p file %p rc %d",inode,file,rc));
>+
>+	cFYI(1, ("Flush inode %p file %p rc %d", inode, file, rc));
> 
> 	return rc;
> }
>@@ -1621,7 +1739,11 @@ ssize_t cifs_user_read(struct file *file, char __user *read_data,
> 	struct smb_com_read_rsp *pSMBr;
> 
> 	xid = GetXid();
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
>+#else
>+	cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
>+#endif
> 	pTcon = cifs_sb->tcon;
> 
> 	if (file->private_data == NULL) {
>@@ -1636,16 +1758,15 @@ ssize_t cifs_user_read(struct file *file, char __user *read_data,
> 	for (total_read = 0, current_offset = read_data;
> 	     read_size > total_read;
> 	     total_read += bytes_read, current_offset += bytes_read) {
>-		current_read_size = min_t(const int, read_size - total_read, 
>+		current_read_size = min_t(const int, read_size - total_read,
> 					  cifs_sb->rsize);
> 		rc = -EAGAIN;
> 		smb_read_data = NULL;
> 		while (rc == -EAGAIN) {
> 			int buf_type = CIFS_NO_BUFFER;
>-			if ((open_file->invalidHandle) && 
>+			if ((open_file->invalidHandle) &&
> 			    (!open_file->closePend)) {
>-				rc = cifs_reopen_file(file->f_dentry->d_inode,
>-					file, TRUE);
>+				rc = cifs_reopen_file(file, TRUE);
> 				if (rc != 0)
> 					break;
> 			}
>@@ -1664,9 +1785,9 @@ ssize_t cifs_user_read(struct file *file, char __user *read_data,
> 					rc = -EFAULT;
> 				}
> 
>-				if(buf_type == CIFS_SMALL_BUFFER)
>+				if (buf_type == CIFS_SMALL_BUFFER)
> 					cifs_small_buf_release(smb_read_data);
>-				else if(buf_type == CIFS_LARGE_BUFFER)
>+				else if (buf_type == CIFS_LARGE_BUFFER)
> 					cifs_buf_release(smb_read_data);
> 				smb_read_data = NULL;
> 			}
>@@ -1703,7 +1824,11 @@ static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
> 	int buf_type = CIFS_NO_BUFFER;
> 
> 	xid = GetXid();
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
>+#else
>+	cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
>+#endif
> 	pTcon = cifs_sb->tcon;
> 
> 	if (file->private_data == NULL) {
>@@ -1715,24 +1840,23 @@ static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
> 	if ((file->f_flags & O_ACCMODE) == O_WRONLY)
> 		cFYI(1, ("attempting read on write only file instance"));
> 
>-	for (total_read = 0, current_offset = read_data; 
>+	for (total_read = 0, current_offset = read_data;
> 	     read_size > total_read;
> 	     total_read += bytes_read, current_offset += bytes_read) {
> 		current_read_size = min_t(const int, read_size - total_read,
> 					  cifs_sb->rsize);
> 		/* For windows me and 9x we do not want to request more
> 		than it negotiated since it will refuse the read then */
>-		if((pTcon->ses) && 
>+		if ((pTcon->ses) &&
> 			!(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
> 			current_read_size = min_t(const int, current_read_size,
> 					pTcon->ses->server->maxBuf - 128);
> 		}
> 		rc = -EAGAIN;
> 		while (rc == -EAGAIN) {
>-			if ((open_file->invalidHandle) && 
>+			if ((open_file->invalidHandle) &&
> 			    (!open_file->closePend)) {
>-				rc = cifs_reopen_file(file->f_dentry->d_inode,
>-					file, TRUE);
>+				rc = cifs_reopen_file(file, TRUE);
> 				if (rc != 0)
> 					break;
> 			}
>@@ -1760,7 +1884,11 @@ static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
> 
> int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
> {
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	struct dentry *dentry = file->f_dentry;
>+#else
>+	struct dentry *dentry = file->f_path.dentry;
>+#endif
> 	int rc, xid;
> 
> 	xid = GetXid();
>@@ -1776,7 +1904,7 @@ int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
> }
> 
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
>-static void cifs_copy_cache_pages(struct address_space *mapping, 
>+static void cifs_copy_cache_pages(struct address_space *mapping,
> 	struct list_head *pages, int bytes_read, char *data,
> 	struct pagevec *plru_pvec)
> {
>@@ -1799,12 +1927,12 @@ static void cifs_copy_cache_pages(struct address_space *mapping,
> 			continue;
> 		}
> 
>-		target = kmap_atomic(page,KM_USER0);
>+		target = kmap_atomic(page, KM_USER0);
> 
> 		if (PAGE_CACHE_SIZE > bytes_read) {
> 			memcpy(target, data, bytes_read);
> 			/* zero the tail end of this partial page */
>-			memset(target + bytes_read, 0, 
>+			memset(target + bytes_read, 0,
> 			       PAGE_CACHE_SIZE - bytes_read);
> 			bytes_read = 0;
> 		} else {
>@@ -1833,7 +1961,7 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
> 	struct cifs_sb_info *cifs_sb;
> 	struct cifsTconInfo *pTcon;
> 	int bytes_read = 0;
>-	unsigned int read_size,i;
>+	unsigned int read_size, i;
> 	char *smb_read_data = NULL;
> 	struct smb_com_read_rsp *pSMBr;
> 	struct pagevec lru_pvec;
>@@ -1846,11 +1974,17 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
> 		return -EBADF;
> 	}
> 	open_file = (struct cifsFileInfo *)file->private_data;
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
>+#else
>+	cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
>+#endif
> 	pTcon = cifs_sb->tcon;
> 
> 	pagevec_init(&lru_pvec, 0);
>-
>+#ifdef CONFIG_CIFS_DEBUG2
>+		cFYI(1, ("rpages: num pages %d", num_pages));
>+#endif
> 	for (i = 0; i < num_pages; ) {
> 		unsigned contig_pages;
> 		struct page *tmp_page;
>@@ -1864,14 +1998,14 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
> 
> 		/* count adjacent pages that we will read into */
> 		contig_pages = 0;
>-		expected_index = 
>+		expected_index =
> 			list_entry(page_list->prev, struct page, lru)->index;
>-		list_for_each_entry_reverse(tmp_page,page_list,lru) {
>+		list_for_each_entry_reverse(tmp_page, page_list, lru) {
> 			if (tmp_page->index == expected_index) {
> 				contig_pages++;
> 				expected_index++;
> 			} else
>-				break; 
>+				break;
> 		}
> 		if (contig_pages + i >  num_pages)
> 			contig_pages = num_pages - i;
>@@ -1883,13 +2017,15 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
> 		/* Read size needs to be in multiples of one page */
> 		read_size = min_t(const unsigned int, read_size,
> 				  cifs_sb->rsize & PAGE_CACHE_MASK);
>-
>+#ifdef CONFIG_CIFS_DEBUG2
>+		cFYI(1, ("rpages: read size 0x%x  contiguous pages %d",
>+				read_size, contig_pages));
>+#endif
> 		rc = -EAGAIN;
> 		while (rc == -EAGAIN) {
>-			if ((open_file->invalidHandle) && 
>+			if ((open_file->invalidHandle) &&
> 			    (!open_file->closePend)) {
>-				rc = cifs_reopen_file(file->f_dentry->d_inode,
>-					file, TRUE);
>+				rc = cifs_reopen_file(file, TRUE);
> 				if (rc != 0)
> 					break;
> 			}
>@@ -1900,11 +2036,11 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
> 					 &bytes_read, &smb_read_data,
> 					 &buf_type);
> 			/* BB more RC checks ? */
>-			if (rc== -EAGAIN) {
>+			if (rc == -EAGAIN) {
> 				if (smb_read_data) {
>-					if(buf_type == CIFS_SMALL_BUFFER)
>+					if (buf_type == CIFS_SMALL_BUFFER)
> 						cifs_small_buf_release(smb_read_data);
>-					else if(buf_type == CIFS_LARGE_BUFFER)
>+					else if (buf_type == CIFS_LARGE_BUFFER)
> 						cifs_buf_release(smb_read_data);
> 					smb_read_data = NULL;
> 				}
>@@ -1912,13 +2048,6 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
> 		}
> 		if ((rc < 0) || (smb_read_data == NULL)) {
> 			cFYI(1, ("Read error in readpages: %d", rc));
>-			/* clean up remaing pages off list */
>-			while (!list_empty(page_list) && (i < num_pages)) {
>-				page = list_entry(page_list->prev, struct page,
>-						  lru);
>-				list_del(&page->lru);
>-				page_cache_release(page);
>-			}
> 			break;
> 		} else if (bytes_read > 0) {
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 19)
>@@ -1934,40 +2063,26 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
> 			if ((int)(bytes_read & PAGE_CACHE_MASK) != bytes_read) {
> 				i++; /* account for partial page */
> 
>-				/* server copy of file can have smaller size 
>+				/* server copy of file can have smaller size
> 				   than client */
>-				/* BB do we need to verify this common case ? 
>-				   this case is ok - if we are at server EOF 
>+				/* BB do we need to verify this common case ?
>+				   this case is ok - if we are at server EOF
> 				   we will hit it on next read */
> 
>-			/* while (!list_empty(page_list) && (i < num_pages)) {
>-					page = list_entry(page_list->prev, 
>-							  struct page, list);
>-					list_del(&page->list);
>-					page_cache_release(page);
>-				}
>-				break; */
>+				/* break; */
> 			}
> 		} else {
> 			cFYI(1, ("No bytes read (%d) at offset %lld . "
> 				 "Cleaning remaining pages from readahead list",
> 				 bytes_read, offset));
>-			/* BB turn off caching and do new lookup on 
>+			/* BB turn off caching and do new lookup on
> 			   file size at server? */
>-			while (!list_empty(page_list) && (i < num_pages)) {
>-				page = list_entry(page_list->prev, struct page,
>-						  lru);
>-				list_del(&page->lru);
>-
>-				/* BB removeme - replace with zero of page? */
>-				page_cache_release(page);
>-			}
> 			break;
> 		}
> 		if (smb_read_data) {
>-			if(buf_type == CIFS_SMALL_BUFFER)
>+			if (buf_type == CIFS_SMALL_BUFFER)
> 				cifs_small_buf_release(smb_read_data);
>-			else if(buf_type == CIFS_LARGE_BUFFER)
>+			else if (buf_type == CIFS_LARGE_BUFFER)
> 				cifs_buf_release(smb_read_data);
> 			smb_read_data = NULL;
> 		}
>@@ -1978,12 +2093,12 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
> 
> /* need to free smb_read_data buf before exit */
> 	if (smb_read_data) {
>-		if(buf_type == CIFS_SMALL_BUFFER)
>+		if (buf_type == CIFS_SMALL_BUFFER)
> 			cifs_small_buf_release(smb_read_data);
>-		else if(buf_type == CIFS_LARGE_BUFFER)
>+		else if (buf_type == CIFS_LARGE_BUFFER)
> 			cifs_buf_release(smb_read_data);
> 		smb_read_data = NULL;
>-	} 
>+	}
> 
> 	FreeXid(xid);
> 	return rc;
>@@ -1999,26 +2114,31 @@ static int cifs_readpage_worker(struct file *file, struct page *page,
> 	page_cache_get(page);
> 	read_data = kmap(page);
> 	/* for reads over a certain size could initiate async read ahead */
>-                                                                                                                           
>+
> 	rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
>-                                                                                                                           
>+
> 	if (rc < 0)
> 		goto io_error;
> 	else
>-		cFYI(1, ("Bytes read %d",rc));
>-                                                                                                                           
>+		cFYI(1, ("Bytes read %d", rc));
>+
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	file->f_dentry->d_inode->i_atime =
> 		current_fs_time(file->f_dentry->d_inode->i_sb);
>-                                                                                                                           
>+#else
>+	file->f_path.dentry->d_inode->i_atime =
>+		current_fs_time(file->f_path.dentry->d_inode->i_sb);
>+#endif
>+
> 	if (PAGE_CACHE_SIZE > rc)
> 		memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
> 
> 	flush_dcache_page(page);
> 	SetPageUptodate(page);
> 	rc = 0;
>-                                                                                                                           
>+
> io_error:
>-        kunmap(page);
>+	kunmap(page);
> 	page_cache_release(page);
> 	return rc;
> }
>@@ -2036,7 +2156,7 @@ static int cifs_readpage(struct file *file, struct page *page)
> 		return -EBADF;
> 	}
> 
>-	cFYI(1, ("readpage %p at offset %d 0x%x\n", 
>+	cFYI(1, ("readpage %p at offset %d 0x%x\n",
> 		 page, (int)offset, (int)offset));
> 
> 	rc = cifs_readpage_worker(file, page, &offset);
>@@ -2069,13 +2189,14 @@ static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
> /* We do not want to update the file size from server for inodes
>    open for write - to avoid races with writepage extending
>    the file - in the future we could consider allowing
>-   refreshing the inode only on increases in the file size 
>+   refreshing the inode only on increases in the file size
>    but this is tricky to do without racing with writebehind
>    page caching in the current Linux kernel design */
> int is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
> {
> 	if (!cifsInode)
> 		return 1;
>+
> 	if (is_inode_writable(cifsInode)) {
> 		/* This inode is open for write at least once */
> 		struct cifs_sb_info *cifs_sb;
>@@ -2086,12 +2207,12 @@ int is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
> 		cifs_sb = CIFS_SB(open_file->pfile->f_dentry->d_inode->i_sb);
> #endif
> 		if ( cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO ) {
>-			/* since no page cache to corrupt on directio 
>+			/* since no page cache to corrupt on directio
> 			we can change size safely */
> 			return 1;
> 		}
> 
>-		if(i_size_read(&cifsInode->vfs_inode) < end_of_file)
>+		if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
> 			return 1;
> 
> 		return 0;
>@@ -2106,7 +2227,7 @@ static int cifs_prepare_write(struct file *file, struct page *page,
> 	loff_t i_size;
> 	loff_t offset;
> 
>-	cFYI(1, ("prepare write for page %p from %d to %d",page,from,to));
>+	cFYI(1, ("prepare write for page %p from %d to %d", page, from, to));
> 	if (PageUptodate(page))
> 		return 0;
> 
>@@ -2145,8 +2266,8 @@ static int cifs_prepare_write(struct file *file, struct page *page,
> 		   this will be written out by commit_write so is fine */
> 	}
> 
>-	/* we do not need to pass errors back 
>-	   e.g. if we do not have read access to the file 
>+	/* we do not need to pass errors back
>+	   e.g. if we do not have read access to the file
> 	   because cifs_commit_write will do the right thing.  -- shaggy */
> 
> 	return 0;
>diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
>index 21b711c..12f72bc 100644
>--- a/fs/cifs/inode.c
>+++ b/fs/cifs/inode.c
>@@ -1,7 +1,7 @@
> /*
>  *   fs/cifs/inode.c
>  *
>- *   Copyright (C) International Business Machines  Corp., 2002,2005
>+ *   Copyright (C) International Business Machines  Corp., 2002,2007
>  *   Author(s): Steve French (sfrench@us.ibm.com)
>  *
>  *   This library is free software; you can redistribute it and/or modify
>@@ -32,6 +32,23 @@
> #include <linux/buffer_head.h>
> #endif
> 
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
>+static inline void clear_nlink(struct inode *inode)
>+{
>+	inode->i_nlink = 0;
>+}
>+static inline void drop_nlink(struct inode *inode)
>+{
>+	inode->i_nlink--;
>+}
>+
>+static inline void inc_nlink(struct inode *inode)
>+{
>+	inode->i_nlink++;
>+}
>+#endif
>+
>+
> int cifs_get_inode_info_unix(struct inode **pinode,
> 	const unsigned char *search_path, struct super_block *sb, int xid)
> {
>@@ -60,14 +77,14 @@ int cifs_get_inode_info_unix(struct inode **pinode,
> 			if (tmp_path == NULL) {
> 				return -ENOMEM;
> 			}
>-        		/* have to skip first of the double backslash of
>+			/* have to skip first of the double backslash of
> 			   UNC name */
> 			strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);
> 			strncat(tmp_path, search_path, MAX_PATHCONF);
> 			rc = connect_to_dfs_path(xid, pTcon->ses,
> 						 /* treename + */ tmp_path,
>-						 cifs_sb->local_nls, 
>-						 cifs_sb->mnt_cifs_flags & 
>+						 cifs_sb->local_nls,
>+						 cifs_sb->mnt_cifs_flags &
> 						    CIFS_MOUNT_MAP_SPECIAL_CHR);
> 			kfree(tmp_path);
> 
>@@ -84,7 +101,7 @@ int cifs_get_inode_info_unix(struct inode **pinode,
> 		/* get new inode */
> 		if (*pinode == NULL) {
> 			*pinode = new_inode(sb);
>-			if (*pinode == NULL) 
>+			if (*pinode == NULL)
> 				return -ENOMEM;
> 			/* Is an i_ino of zero legal? */
> 			/* Are there sanity checks we can use to ensure that
>@@ -93,9 +110,9 @@ int cifs_get_inode_info_unix(struct inode **pinode,
> 				(*pinode)->i_ino =
> 					(unsigned long)findData.UniqueId;
> 			} /* note ino incremented to unique num in new_inode */
>-			if(sb->s_flags & MS_NOATIME)
>+			if (sb->s_flags & MS_NOATIME)
> 				(*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
>-				
>+
> 			insert_inode_hash(*pinode);
> 		}
> 
>@@ -106,7 +123,7 @@ int cifs_get_inode_info_unix(struct inode **pinode,
> 		cifsInfo->time = jiffies;
> 		cFYI(1, ("New time %ld", cifsInfo->time));
> 		/* this is ok to set on every inode revalidate */
>-		atomic_set(&cifsInfo->inUse,1);
>+		atomic_set(&cifsInfo->inUse, 1);
> 
> 		inode->i_atime =
> 		    cifs_NTtimeToUnix(le64_to_cpu(findData.LastAccessTime));
>@@ -117,8 +134,8 @@ int cifs_get_inode_info_unix(struct inode **pinode,
> 		    cifs_NTtimeToUnix(le64_to_cpu(findData.LastStatusChange));
> 		inode->i_mode = le64_to_cpu(findData.Permissions);
> 		/* since we set the inode type below we need to mask off
>-                   to avoid strange results if bits set above */
>-                        inode->i_mode &= ~S_IFMT;
>+		   to avoid strange results if bits set above */
>+			inode->i_mode &= ~S_IFMT;
> 		if (type == UNIX_FILE) {
> 			inode->i_mode |= S_IFREG;
> 		} else if (type == UNIX_SYMLINK) {
>@@ -140,10 +157,19 @@ int cifs_get_inode_info_unix(struct inode **pinode,
> 		} else {
> 			/* safest to call it a file if we do not know */
> 			inode->i_mode |= S_IFREG;
>-			cFYI(1,("unknown type %d",type));
>+			cFYI(1, ("unknown type %d", type));
> 		}
>-		inode->i_uid = le64_to_cpu(findData.Uid);
>-		inode->i_gid = le64_to_cpu(findData.Gid);
>+
>+		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
>+			inode->i_uid = cifs_sb->mnt_uid;
>+		else
>+			inode->i_uid = le64_to_cpu(findData.Uid);
>+
>+		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
>+			inode->i_gid = cifs_sb->mnt_gid;
>+		else
>+			inode->i_gid = le64_to_cpu(findData.Gid);
>+
> 		inode->i_nlink = le64_to_cpu(findData.Nlinks);
> 
> 		spin_lock(&inode->i_lock);
>@@ -177,22 +203,21 @@ int cifs_get_inode_info_unix(struct inode **pinode,
> 			inode->i_op = &cifs_file_inode_ops;
> 			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
> 				if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
>-					inode->i_fop = 
>+					inode->i_fop =
> 						&cifs_file_direct_nobrl_ops;
> 				else
> 					inode->i_fop = &cifs_file_direct_ops;
>-			} else if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
>+			} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
> 				inode->i_fop = &cifs_file_nobrl_ops;
>-			else /* not direct, send byte range locks */ 
>+			else /* not direct, send byte range locks */
> 				inode->i_fop = &cifs_file_ops;
> 
>-			inode->i_data.a_ops = &cifs_addr_ops;
>-#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
> 			/* check if server can support readpages */
>-			if(pTcon->ses->server->maxBuf < 
>+			if (pTcon->ses->server->maxBuf <
> 			    PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
> 				inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
>-#endif
>+			else
>+				inode->i_data.a_ops = &cifs_addr_ops;
> 		} else if (S_ISDIR(inode->i_mode)) {
> 			cFYI(1, ("Directory inode"));
> 			inode->i_op = &cifs_dir_inode_ops;
>@@ -210,7 +235,7 @@ int cifs_get_inode_info_unix(struct inode **pinode,
> 	return rc;
> }
> 
>-static int decode_sfu_inode(struct inode * inode, __u64 size,
>+static int decode_sfu_inode(struct inode *inode, __u64 size,
> 			    const unsigned char *path,
> 			    struct cifs_sb_info *cifs_sb, int xid)
> {
>@@ -220,34 +245,34 @@ static int decode_sfu_inode(struct inode * inode, __u64 size,
> 	struct cifsTconInfo *pTcon = cifs_sb->tcon;
> 	char buf[24];
> 	unsigned int bytes_read;
>-	char * pbuf;
>+	char *pbuf;
> 
> 	pbuf = buf;
> 
>-	if(size == 0) {
>+	if (size == 0) {
> 		inode->i_mode |= S_IFIFO;
> 		return 0;
> 	} else if (size < 8) {
> 		return -EINVAL;	 /* EOPNOTSUPP? */
> 	}
>-		
>+
> 	rc = CIFSSMBOpen(xid, pTcon, path, FILE_OPEN, GENERIC_READ,
> 			 CREATE_NOT_DIR, &netfid, &oplock, NULL,
> 			 cifs_sb->local_nls,
> 			 cifs_sb->mnt_cifs_flags &
> 				CIFS_MOUNT_MAP_SPECIAL_CHR);
>-	if (rc==0) {
>+	if (rc == 0) {
> 		int buf_type = CIFS_NO_BUFFER;
> 			/* Read header */
> 		rc = CIFSSMBRead(xid, pTcon,
>-			         netfid,
>+				 netfid,
> 				 24 /* length */, 0 /* offset */,
> 				 &bytes_read, &pbuf, &buf_type);
>-		if((rc == 0) && (bytes_read >= 8)) {
>-			if(memcmp("IntxBLK", pbuf, 8) == 0) {
>-				cFYI(1,("Block device"));
>+		if ((rc == 0) && (bytes_read >= 8)) {
>+			if (memcmp("IntxBLK", pbuf, 8) == 0) {
>+				cFYI(1, ("Block device"));
> 				inode->i_mode |= S_IFBLK;
>-				if(bytes_read == 24) {
>+				if (bytes_read == 24) {
> 					/* we have enough to decode dev num */
> 					__u64 mjr; /* major */
> 					__u64 mnr; /* minor */
>@@ -255,37 +280,36 @@ static int decode_sfu_inode(struct inode * inode, __u64 size,
> 					mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
> 					inode->i_rdev = MKDEV(mjr, mnr);
> 				}
>-			} else if(memcmp("IntxCHR", pbuf, 8) == 0) {
>-				cFYI(1,("Char device"));
>+			} else if (memcmp("IntxCHR", pbuf, 8) == 0) {
>+				cFYI(1, ("Char device"));
> 				inode->i_mode |= S_IFCHR;
>-				if(bytes_read == 24) {
>+				if (bytes_read == 24) {
> 					/* we have enough to decode dev num */
> 					__u64 mjr; /* major */
> 					__u64 mnr; /* minor */
> 					mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
> 					mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
> 					inode->i_rdev = MKDEV(mjr, mnr);
>-                                }
>-			} else if(memcmp("IntxLNK", pbuf, 7) == 0) {
>-				cFYI(1,("Symlink"));
>+				}
>+			} else if (memcmp("IntxLNK", pbuf, 7) == 0) {
>+				cFYI(1, ("Symlink"));
> 				inode->i_mode |= S_IFLNK;
> 			} else {
> 				inode->i_mode |= S_IFREG; /* file? */
>-				rc = -EOPNOTSUPP; 
>+				rc = -EOPNOTSUPP;
> 			}
> 		} else {
> 			inode->i_mode |= S_IFREG; /* then it is a file */
>-			rc = -EOPNOTSUPP; /* or some unknown SFU type */	
>-		}		
>+			rc = -EOPNOTSUPP; /* or some unknown SFU type */
>+		}
> 		CIFSSMBClose(xid, pTcon, netfid);
> 	}
> 	return rc;
>-	
> }
> 
> #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID)  /* SETFILEBITS valid bits */
> 
>-static int get_sfu_uid_mode(struct inode * inode,
>+static int get_sfu_uid_mode(struct inode *inode,
> 			const unsigned char *path,
> 			struct cifs_sb_info *cifs_sb, int xid)
> {
>@@ -296,15 +320,15 @@ static int get_sfu_uid_mode(struct inode * inode,
> 
> 	rc = CIFSSMBQueryEA(xid, cifs_sb->tcon, path, "SETFILEBITS",
> 			ea_value, 4 /* size of buf */, cifs_sb->local_nls,
>-                        cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
>-	if(rc < 0)
>+		cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
>+	if (rc < 0)
> 		return (int)rc;
> 	else if (rc > 3) {
> 		mode = le32_to_cpu(*((__le32 *)ea_value));
>-		inode->i_mode &= ~SFBITS_MASK; 
>-		cFYI(1,("special bits 0%o org mode 0%o", mode, inode->i_mode));
>+		inode->i_mode &= ~SFBITS_MASK;
>+		cFYI(1, ("special bits 0%o org mode 0%o", mode, inode->i_mode));
> 		inode->i_mode = (mode &  SFBITS_MASK) | inode->i_mode;
>-		cFYI(1,("special mode bits 0%o", mode));
>+		cFYI(1, ("special mode bits 0%o", mode));
> 		return 0;
> 	} else {
> 		return 0;
>@@ -312,8 +336,6 @@ static int get_sfu_uid_mode(struct inode * inode,
> #else
> 	return -EOPNOTSUPP;
> #endif
>-
>-		
> }
> 
> int cifs_get_inode_info(struct inode **pinode,
>@@ -329,11 +351,11 @@ int cifs_get_inode_info(struct inode **pinode,
> 	int adjustTZ = FALSE;
> 
> 	pTcon = cifs_sb->tcon;
>-	cFYI(1,("Getting info on %s", search_path));
>+	cFYI(1, ("Getting info on %s", search_path));
> 
> 	if ((pfindData == NULL) && (*pinode != NULL)) {
> 		if (CIFS_I(*pinode)->clientCanCacheRead) {
>-			cFYI(1,("No need to revalidate cached inode sizes"));
>+			cFYI(1, ("No need to revalidate cached inode sizes"));
> 			return rc;
> 		}
> 	}
>@@ -352,14 +374,13 @@ int cifs_get_inode_info(struct inode **pinode,
> 		/* BB optimize code so we do not make the above call
> 		when server claims no NT SMB support and the above call
> 		failed at least once - set flag in tcon or mount */
>-		if((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
>+		if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
> 			rc = SMBQueryInformation(xid, pTcon, search_path,
>-					pfindData, cifs_sb->local_nls, 
>+					pfindData, cifs_sb->local_nls,
> 					cifs_sb->mnt_cifs_flags &
> 					  CIFS_MOUNT_MAP_SPECIAL_CHR);
> 			adjustTZ = TRUE;
> 		}
>-		
> 	}
> 	/* dump_mem("\nQPathInfo return data",&findData, sizeof(findData)); */
> 	if (rc) {
>@@ -379,8 +400,8 @@ int cifs_get_inode_info(struct inode **pinode,
> 			strncat(tmp_path, search_path, MAX_PATHCONF);
> 			rc = connect_to_dfs_path(xid, pTcon->ses,
> 						 /* treename + */ tmp_path,
>-						 cifs_sb->local_nls, 
>-						 cifs_sb->mnt_cifs_flags & 
>+						 cifs_sb->local_nls,
>+						 cifs_sb->mnt_cifs_flags &
> 						   CIFS_MOUNT_MAP_SPECIAL_CHR);
> 			kfree(tmp_path);
> 			/* BB fix up inode etc. */
>@@ -414,22 +435,22 @@ int cifs_get_inode_info(struct inode **pinode,
> 			   there Windows server or network appliances for which
> 			   IndexNumber field is not guaranteed unique? */
> 
>-			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM){
>+			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
> 				int rc1 = 0;
> 				__u64 inode_num;
> 
>-				rc1 = CIFSGetSrvInodeNumber(xid, pTcon, 
>-					search_path, &inode_num, 
>+				rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
>+					search_path, &inode_num,
> 					cifs_sb->local_nls,
> 					cifs_sb->mnt_cifs_flags &
> 						CIFS_MOUNT_MAP_SPECIAL_CHR);
> 				if (rc1) {
>-					cFYI(1,("GetSrvInodeNum rc %d", rc1));
>+					cFYI(1, ("GetSrvInodeNum rc %d", rc1));
> 					/* BB EOPNOSUPP disable SERVER_INUM? */
> 				} else /* do we need cast or hash to ino? */
> 					(*pinode)->i_ino = inode_num;
> 			} /* else ino incremented to unique num in new_inode*/
>-			if(sb->s_flags & MS_NOATIME)
>+			if (sb->s_flags & MS_NOATIME)
> 				(*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
> 			insert_inode_hash(*pinode);
> 		}
>@@ -446,7 +467,7 @@ int cifs_get_inode_info(struct inode **pinode,
> 		(pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFE00;*/
> 
> 		/* Linux can not store file creation time so ignore it */
>-		if(pfindData->LastAccessTime)
>+		if (pfindData->LastAccessTime)
> 			inode->i_atime = cifs_NTtimeToUnix
> 				(le64_to_cpu(pfindData->LastAccessTime));
> 		else /* do not need to use current_fs_time - time not stored */
>@@ -456,9 +477,9 @@ int cifs_get_inode_info(struct inode **pinode,
> 		inode->i_ctime =
> 		    cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
> 		cFYI(0, ("Attributes came in as 0x%x", attr));
>-		if(adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
>+		if (adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
> 			inode->i_ctime.tv_sec += pTcon->ses->server->timeAdj;
>-	                inode->i_mtime.tv_sec += pTcon->ses->server->timeAdj;
>+			inode->i_mtime.tv_sec += pTcon->ses->server->timeAdj;
> 		}
> 
> 		/* set default mode. will override for dirs below */
>@@ -466,8 +487,9 @@ int cifs_get_inode_info(struct inode **pinode,
> 			/* new inode, can safely set these fields */
> 			inode->i_mode = cifs_sb->mnt_file_mode;
> 		else /* since we set the inode type below we need to mask off
>-		     to avoid strange results if type changes and both get orred in */ 
>-			inode->i_mode &= ~S_IFMT; 
>+		     to avoid strange results if type changes and both
>+		     get orred in */
>+			inode->i_mode &= ~S_IFMT;
> /*		if (attr & ATTR_REPARSE)  */
> 		/* We no longer handle these as symlinks because we could not
> 		   follow them due to the absolute path with drive letter */
>@@ -485,13 +507,13 @@ int cifs_get_inode_info(struct inode **pinode,
> /* BB Finish for SFU style symlinks and devices */
> 		} else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) &&
> 			   (cifsInfo->cifsAttrs & ATTR_SYSTEM)) {
>-			if (decode_sfu_inode(inode, 
>+			if (decode_sfu_inode(inode,
> 					 le64_to_cpu(pfindData->EndOfFile),
> 					 search_path,
> 					 cifs_sb, xid)) {
>-				cFYI(1,("Unrecognized sfu inode type"));
>+				cFYI(1, ("Unrecognized sfu inode type"));
> 			}
>-			cFYI(1,("sfu mode 0%o",inode->i_mode));
>+			cFYI(1, ("sfu mode 0%o", inode->i_mode));
> 		} else {
> 			inode->i_mode |= S_IFREG;
> 			/* treat the dos attribute of read-only as read-only
>@@ -507,12 +529,12 @@ int cifs_get_inode_info(struct inode **pinode,
> 		/* BB add code here -
> 		   validate if device or weird share or device type? */
> 		}
>-		
>+
> 		spin_lock(&inode->i_lock);
> 		if (is_size_safe_to_change(cifsInfo, le64_to_cpu(pfindData->EndOfFile))) {
> 			/* can not safely shrink the file size here if the
> 			   client is writing to it due to potential races */
>-			i_size_write(inode,le64_to_cpu(pfindData->EndOfFile));
>+			i_size_write(inode, le64_to_cpu(pfindData->EndOfFile));
> 
> 			/* 512 bytes (2**9) is the fake blocksize that must be
> 			   used for this calculation */
>@@ -523,17 +545,19 @@ int cifs_get_inode_info(struct inode **pinode,
> 
> 		inode->i_nlink = le32_to_cpu(pfindData->NumberOfLinks);
> 
>-		/* BB fill in uid and gid here? with help from winbind? 
>+		/* BB fill in uid and gid here? with help from winbind?
> 		   or retrieve from NTFS stream extended attribute */
>-		if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
>+		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
> 			/* fill in uid, gid, mode from server ACL */
>+			/* BB FIXME this should also take into account the
>+			 * default uid specified on mount if present */
> 			get_sfu_uid_mode(inode, search_path, cifs_sb, xid);
> 		} else if (atomic_read(&cifsInfo->inUse) == 0) {
> 			inode->i_uid = cifs_sb->mnt_uid;
> 			inode->i_gid = cifs_sb->mnt_gid;
> 			/* set so we do not keep refreshing these fields with
> 			   bad data after user has changed them in memory */
>-			atomic_set(&cifsInfo->inUse,1);
>+			atomic_set(&cifsInfo->inUse, 1);
> 		}
> 
> 		if (S_ISREG(inode->i_mode)) {
>@@ -545,17 +569,16 @@ int cifs_get_inode_info(struct inode **pinode,
> 						&cifs_file_direct_nobrl_ops;
> 				else
> 					inode->i_fop = &cifs_file_direct_ops;
>-			} else if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
>+			} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
> 				inode->i_fop = &cifs_file_nobrl_ops;
> 			else /* not direct, send byte range locks */
> 				inode->i_fop = &cifs_file_ops;
> 
>-			inode->i_data.a_ops = &cifs_addr_ops;
>-#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
>-			if(pTcon->ses->server->maxBuf < 
>+			if (pTcon->ses->server->maxBuf <
> 			     PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
> 				inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
>-#endif
>+			else
>+				inode->i_data.a_ops = &cifs_addr_ops;
> 		} else if (S_ISDIR(inode->i_mode)) {
> 			cFYI(1, ("Directory inode"));
> 			inode->i_op = &cifs_dir_inode_ops;
>@@ -580,10 +603,11 @@ void cifs_read_inode(struct inode *inode)
> 
> 	cifs_sb = CIFS_SB(inode->i_sb);
> 	xid = GetXid();
>-	if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)
>-		cifs_get_inode_info_unix(&inode, "", inode->i_sb,xid);
>+
>+	if (cifs_sb->tcon->unix_ext)
>+		cifs_get_inode_info_unix(&inode, "", inode->i_sb, xid);
> 	else
>-		cifs_get_inode_info(&inode, "", NULL, inode->i_sb,xid);
>+		cifs_get_inode_info(&inode, "", NULL, inode->i_sb, xid);
> 	/* can not call macro FreeXid here since in a void func */
> 	_FreeXid(xid);
> }
>@@ -602,7 +626,7 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
> 
> 	xid = GetXid();
> 
>-	if(inode)
>+	if (inode)
> 		cifs_sb = CIFS_SB(inode->i_sb);
> 	else
> 		cifs_sb = CIFS_SB(direntry->d_sb);
>@@ -610,19 +634,31 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
> 
> 	/* Unlink can be called from rename so we can not grab the sem here
> 	   since we deadlock otherwise */
>-/*	down(&direntry->d_sb->s_vfs_rename_sem);*/
>+/*	mutex_lock(&direntry->d_sb->s_vfs_rename_mutex);*/
> 	full_path = build_path_from_dentry(direntry);
>-/*	up(&direntry->d_sb->s_vfs_rename_sem);*/
>+/*	mutex_unlock(&direntry->d_sb->s_vfs_rename_mutex);*/
> 	if (full_path == NULL) {
> 		FreeXid(xid);
> 		return -ENOMEM;
> 	}
>-	rc = CIFSSMBDelFile(xid, pTcon, full_path, cifs_sb->local_nls,
>+
>+	if ((pTcon->ses->capabilities & CAP_UNIX) &&
>+		(CIFS_UNIX_POSIX_PATH_OPS_CAP &
>+			le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
>+		rc = CIFSPOSIXDelFile(xid, pTcon, full_path,
>+			SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
> 			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
>+		cFYI(1,("posix del rc %d",rc));
>+		if ((rc == 0) || (rc == -ENOENT))
>+			goto psx_del_no_retry;
>+	}
> 
>+	rc = CIFSSMBDelFile(xid, pTcon, full_path, cifs_sb->local_nls,
>+			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
>+psx_del_no_retry:
> 	if (!rc) {
> 		if (direntry->d_inode)
>-			direntry->d_inode->i_nlink--;
>+			drop_nlink(direntry->d_inode);
> 	} else if (rc == -ENOENT) {
> 		d_drop(direntry);
> 	} else if (rc == -ETXTBSY) {
>@@ -632,16 +668,16 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
> 		rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, DELETE,
> 				 CREATE_NOT_DIR | CREATE_DELETE_ON_CLOSE,
> 				 &netfid, &oplock, NULL, cifs_sb->local_nls,
>-				 cifs_sb->mnt_cifs_flags & 
>+				 cifs_sb->mnt_cifs_flags &
> 					CIFS_MOUNT_MAP_SPECIAL_CHR);
>-		if (rc==0) {
>+		if (rc == 0) {
> 			CIFSSMBRenameOpenFile(xid, pTcon, netfid, NULL,
>-					      cifs_sb->local_nls, 
>-					      cifs_sb->mnt_cifs_flags & 
>+					      cifs_sb->local_nls,
>+					      cifs_sb->mnt_cifs_flags &
> 						CIFS_MOUNT_MAP_SPECIAL_CHR);
> 			CIFSSMBClose(xid, pTcon, netfid);
> 			if (direntry->d_inode)
>-				direntry->d_inode->i_nlink--;
>+				drop_nlink(direntry->d_inode);
> 		}
> 	} else if (rc == -EACCES) {
> 		/* try only if r/o attribute set in local lookup data? */
>@@ -653,7 +689,7 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
> 				rc = CIFSSMBSetTimes(xid, pTcon, full_path,
> 						     pinfo_buf,
> 						     cifs_sb->local_nls,
>-						     cifs_sb->mnt_cifs_flags & 
>+						     cifs_sb->mnt_cifs_flags &
> 							CIFS_MOUNT_MAP_SPECIAL_CHR);
> 			else
> 				rc = -EOPNOTSUPP;
>@@ -664,7 +700,7 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
> 			/*	rc = CIFSSMBSetAttrLegacy(xid, pTcon,
> 							  full_path,
> 							  (__u16)ATTR_NORMAL,
>-							  cifs_sb->local_nls); 
>+							  cifs_sb->local_nls);
> 			   For some strange reason it seems that NT4 eats the
> 			   old setattr call without actually setting the
> 			   attributes so on to the third attempted workaround
>@@ -677,9 +713,9 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
> 						 FILE_WRITE_ATTRIBUTES, 0,
> 						 &netfid, &oplock, NULL,
> 						 cifs_sb->local_nls,
>-						 cifs_sb->mnt_cifs_flags & 
>+						 cifs_sb->mnt_cifs_flags &
> 						    CIFS_MOUNT_MAP_SPECIAL_CHR);
>-				if (rc==0) {
>+				if (rc == 0) {
> 					rc = CIFSSMBSetFileTimes(xid, pTcon,
> 								 pinfo_buf,
> 								 netfid);
>@@ -688,14 +724,14 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
> 			}
> 			kfree(pinfo_buf);
> 		}
>-		if (rc==0) {
>-			rc = CIFSSMBDelFile(xid, pTcon, full_path, 
>-					    cifs_sb->local_nls, 
>-					    cifs_sb->mnt_cifs_flags & 
>+		if (rc == 0) {
>+			rc = CIFSSMBDelFile(xid, pTcon, full_path,
>+					    cifs_sb->local_nls,
>+					    cifs_sb->mnt_cifs_flags &
> 						CIFS_MOUNT_MAP_SPECIAL_CHR);
> 			if (!rc) {
> 				if (direntry->d_inode)
>-					direntry->d_inode->i_nlink--;
>+					drop_nlink(direntry->d_inode);
> 			} else if (rc == -ETXTBSY) {
> 				int oplock = FALSE;
> 				__u16 netfid;
>@@ -705,10 +741,10 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
> 						 CREATE_NOT_DIR |
> 						 CREATE_DELETE_ON_CLOSE,
> 						 &netfid, &oplock, NULL,
>-						 cifs_sb->local_nls, 
>-						 cifs_sb->mnt_cifs_flags & 
>+						 cifs_sb->local_nls,
>+						 cifs_sb->mnt_cifs_flags &
> 						    CIFS_MOUNT_MAP_SPECIAL_CHR);
>-				if (rc==0) {
>+				if (rc == 0) {
> 					CIFSSMBRenameOpenFile(xid, pTcon,
> 						netfid, NULL,
> 						cifs_sb->local_nls,
>@@ -716,7 +752,7 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
> 						    CIFS_MOUNT_MAP_SPECIAL_CHR);
> 					CIFSSMBClose(xid, pTcon, netfid);
> 					if (direntry->d_inode)
>-			                        direntry->d_inode->i_nlink--;
>+						drop_nlink(direntry->d_inode);
> 				}
> 			/* BB if rc = -ETXTBUSY goto the rename logic BB */
> 			}
>@@ -728,7 +764,7 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
> 					   when needed */
> 		direntry->d_inode->i_ctime = current_fs_time(inode->i_sb);
> 	}
>-	if(inode) {
>+	if (inode) {
> 		inode->i_ctime = inode->i_mtime = current_fs_time(inode->i_sb);
> 		cifsInode = CIFS_I(inode);
> 		cifsInode->time = 0;	/* force revalidate of dir as well */
>@@ -739,6 +775,137 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
> 	return rc;
> }
> 
>+static void posix_fill_in_inode(struct inode *tmp_inode,
>+	FILE_UNIX_BASIC_INFO *pData, int *pobject_type, int isNewInode)
>+{
>+	loff_t local_size;
>+	struct timespec local_mtime;
>+
>+	struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
>+	struct cifs_sb_info *cifs_sb = CIFS_SB(tmp_inode->i_sb);
>+
>+	__u32 type = le32_to_cpu(pData->Type);
>+	__u64 num_of_bytes = le64_to_cpu(pData->NumOfBytes);
>+	__u64 end_of_file = le64_to_cpu(pData->EndOfFile);
>+	cifsInfo->time = jiffies;
>+	atomic_inc(&cifsInfo->inUse);
>+
>+	/* save mtime and size */
>+	local_mtime = tmp_inode->i_mtime;
>+	local_size  = tmp_inode->i_size;
>+
>+	tmp_inode->i_atime =
>+	    cifs_NTtimeToUnix(le64_to_cpu(pData->LastAccessTime));
>+	tmp_inode->i_mtime =
>+	    cifs_NTtimeToUnix(le64_to_cpu(pData->LastModificationTime));
>+	tmp_inode->i_ctime =
>+	    cifs_NTtimeToUnix(le64_to_cpu(pData->LastStatusChange));
>+
>+	tmp_inode->i_mode = le64_to_cpu(pData->Permissions);
>+	/* since we set the inode type below we need to mask off type
>+	   to avoid strange results if bits above were corrupt */
>+	tmp_inode->i_mode &= ~S_IFMT;
>+	if (type == UNIX_FILE) {
>+		*pobject_type = DT_REG;
>+		tmp_inode->i_mode |= S_IFREG;
>+	} else if (type == UNIX_SYMLINK) {
>+		*pobject_type = DT_LNK;
>+		tmp_inode->i_mode |= S_IFLNK;
>+	} else if (type == UNIX_DIR) {
>+		*pobject_type = DT_DIR;
>+		tmp_inode->i_mode |= S_IFDIR;
>+	} else if (type == UNIX_CHARDEV) {
>+		*pobject_type = DT_CHR;
>+		tmp_inode->i_mode |= S_IFCHR;
>+		tmp_inode->i_rdev = MKDEV(le64_to_cpu(pData->DevMajor),
>+				le64_to_cpu(pData->DevMinor) & MINORMASK);
>+	} else if (type == UNIX_BLOCKDEV) {
>+		*pobject_type = DT_BLK;
>+		tmp_inode->i_mode |= S_IFBLK;
>+		tmp_inode->i_rdev = MKDEV(le64_to_cpu(pData->DevMajor),
>+				le64_to_cpu(pData->DevMinor) & MINORMASK);
>+	} else if (type == UNIX_FIFO) {
>+		*pobject_type = DT_FIFO;
>+		tmp_inode->i_mode |= S_IFIFO;
>+	} else if (type == UNIX_SOCKET) {
>+		*pobject_type = DT_SOCK;
>+		tmp_inode->i_mode |= S_IFSOCK;
>+	} else {
>+		/* safest to just call it a file */
>+		*pobject_type = DT_REG;
>+		tmp_inode->i_mode |= S_IFREG;
>+		cFYI(1, ("unknown inode type %d", type));
>+	}
>+
>+#ifdef CONFIG_CIFS_DEBUG2
>+	cFYI(1, ("object type: %d", type));
>+#endif
>+	tmp_inode->i_uid = le64_to_cpu(pData->Uid);
>+	tmp_inode->i_gid = le64_to_cpu(pData->Gid);
>+	tmp_inode->i_nlink = le64_to_cpu(pData->Nlinks);
>+
>+	spin_lock(&tmp_inode->i_lock);
>+	if (is_size_safe_to_change(cifsInfo, end_of_file)) {
>+		/* can not safely change the file size here if the
>+		client is writing to it due to potential races */
>+		i_size_write(tmp_inode, end_of_file);
>+
>+	/* 512 bytes (2**9) is the fake blocksize that must be used */
>+	/* for this calculation, not the real blocksize */
>+		tmp_inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
>+	}
>+	spin_unlock(&tmp_inode->i_lock);
>+
>+	if (S_ISREG(tmp_inode->i_mode)) {
>+		cFYI(1, ("File inode"));
>+		tmp_inode->i_op = &cifs_file_inode_ops;
>+
>+		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
>+			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
>+				tmp_inode->i_fop = &cifs_file_direct_nobrl_ops;
>+			else
>+				tmp_inode->i_fop = &cifs_file_direct_ops;
>+
>+		} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
>+			tmp_inode->i_fop = &cifs_file_nobrl_ops;
>+		else
>+			tmp_inode->i_fop = &cifs_file_ops;
>+
>+		if ((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
>+		   (cifs_sb->tcon->ses->server->maxBuf <
>+			PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE))
>+			tmp_inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
>+		else
>+			tmp_inode->i_data.a_ops = &cifs_addr_ops;
>+
>+		if (isNewInode)
>+			return; /* No sense invalidating pages for new inode
>+				   since we we have not started caching
>+				   readahead file data yet */
>+
>+		if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
>+			(local_size == tmp_inode->i_size)) {
>+			cFYI(1, ("inode exists but unchanged"));
>+		} else {
>+			/* file may have changed on server */
>+			cFYI(1, ("invalidate inode, readdir detected change"));
>+			invalidate_remote_inode(tmp_inode);
>+		}
>+	} else if (S_ISDIR(tmp_inode->i_mode)) {
>+		cFYI(1, ("Directory inode"));
>+		tmp_inode->i_op = &cifs_dir_inode_ops;
>+		tmp_inode->i_fop = &cifs_dir_ops;
>+	} else if (S_ISLNK(tmp_inode->i_mode)) {
>+		cFYI(1, ("Symbolic Link inode"));
>+		tmp_inode->i_op = &cifs_symlink_inode_ops;
>+/* tmp_inode->i_fop = *//* do not need to set to anything */
>+	} else {
>+		cFYI(1, ("Special inode"));
>+		init_special_inode(tmp_inode, tmp_inode->i_mode,
>+				   tmp_inode->i_rdev);
>+	}
>+}
>+
> int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
> {
> 	int rc = 0;
>@@ -760,6 +927,80 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
> 		FreeXid(xid);
> 		return -ENOMEM;
> 	}
>+
>+	if ((pTcon->ses->capabilities & CAP_UNIX) &&
>+		(CIFS_UNIX_POSIX_PATH_OPS_CAP &
>+			le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
>+		u32 oplock = 0;
>+		FILE_UNIX_BASIC_INFO * pInfo =
>+			kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
>+		if (pInfo == NULL) {
>+			rc = -ENOMEM;
>+			goto mkdir_out;
>+		}
>+
>+		mode &= ~current->fs->umask;
>+		rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
>+				mode, NULL /* netfid */, pInfo, &oplock,
>+				full_path, cifs_sb->local_nls,
>+				cifs_sb->mnt_cifs_flags &
>+					CIFS_MOUNT_MAP_SPECIAL_CHR);
>+		if (rc == -EOPNOTSUPP) {
>+			kfree(pInfo);
>+			goto mkdir_retry_old;
>+		} else if (rc) {
>+			cFYI(1, ("posix mkdir returned 0x%x", rc));
>+			d_drop(direntry);
>+		} else {
>+			int obj_type;
>+			if (pInfo->Type == -1) /* no return info - go query */ {
>+				kfree(pInfo);
>+				goto mkdir_get_info;
>+			}
>+/*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
>+	to set uid/gid */
>+			inc_nlink(inode);
>+			if (pTcon->nocase)
>+				direntry->d_op = &cifs_ci_dentry_ops;
>+			else
>+				direntry->d_op = &cifs_dentry_ops;
>+
>+			newinode = new_inode(inode->i_sb);
>+			if (newinode == NULL) {
>+				kfree(pInfo);
>+				goto mkdir_get_info;
>+			}
>+			/* Is an i_ino of zero legal? */
>+			/* Are there sanity checks we can use to ensure that
>+			   the server is really filling in that field? */
>+			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
>+				newinode->i_ino =
>+					(unsigned long)pInfo->UniqueId;
>+			} /* note ino incremented to unique num in new_inode */
>+			if (inode->i_sb->s_flags & MS_NOATIME)
>+				newinode->i_flags |= S_NOATIME | S_NOCMTIME;
>+			newinode->i_nlink = 2;
>+
>+			insert_inode_hash(newinode);
>+			d_instantiate(direntry, newinode);
>+
>+			/* we already checked in POSIXCreate whether
>+			   frame was long enough */
>+			posix_fill_in_inode(direntry->d_inode,
>+					pInfo, &obj_type, 1 /* NewInode */);
>+#ifdef CONFIG_CIFS_DEBUG2
>+			cFYI(1, ("instantiated dentry %p %s to inode %p",
>+				direntry, direntry->d_name.name, newinode));
>+
>+			if (newinode->i_nlink != 2)
>+				cFYI(1, ("unexpected number of links %d",
>+					newinode->i_nlink));
>+#endif
>+		}
>+		kfree(pInfo);
>+		goto mkdir_out;
>+	}
>+mkdir_retry_old:
> 	/* BB add setting the equivalent of mode via CreateX w/ACLs */
> 	rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
> 			  cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
>@@ -767,22 +1008,25 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
> 		cFYI(1, ("cifs_mkdir returned 0x%x", rc));
> 		d_drop(direntry);
> 	} else {
>-		inode->i_nlink++;
>-		if (pTcon->ses->capabilities & CAP_UNIX)
>+mkdir_get_info:
>+		inc_nlink(inode);
>+		if (pTcon->unix_ext)
> 			rc = cifs_get_inode_info_unix(&newinode, full_path,
>-						      inode->i_sb,xid);
>+						      inode->i_sb, xid);
> 		else
> 			rc = cifs_get_inode_info(&newinode, full_path, NULL,
>-						 inode->i_sb,xid);
>+						 inode->i_sb, xid);
> 
> 		if (pTcon->nocase)
> 			direntry->d_op = &cifs_ci_dentry_ops;
> 		else
> 			direntry->d_op = &cifs_dentry_ops;
> 		d_instantiate(direntry, newinode);
>-		if (direntry->d_inode)
>-			direntry->d_inode->i_nlink = 2;
>-		if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) {
>+		 /* setting nlink not necessary except in cases where we
>+		  * failed to get it from the server or was set bogus */
>+		if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
>+				direntry->d_inode->i_nlink = 2;
>+		if (pTcon->unix_ext) {
> 			mode &= ~current->fs->umask;
> 			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
> 				CIFSSMBUnixSetPerms(xid, pTcon, full_path,
>@@ -798,26 +1042,27 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
> 						    mode, (__u64)-1,
> 						    (__u64)-1, 0 /* dev_t */,
> 						    cifs_sb->local_nls,
>-						    cifs_sb->mnt_cifs_flags & 
>+						    cifs_sb->mnt_cifs_flags &
> 						    CIFS_MOUNT_MAP_SPECIAL_CHR);
> 			}
> 		} else {
> 			/* BB to be implemented via Windows secrty descriptors
> 			   eg CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
> 						 -1, -1, local_nls); */
>-			if(direntry->d_inode) {
>+			if (direntry->d_inode) {
> 				direntry->d_inode->i_mode = mode;
> 				direntry->d_inode->i_mode |= S_IFDIR;
>-				if(cifs_sb->mnt_cifs_flags & 
>+				if (cifs_sb->mnt_cifs_flags &
> 				     CIFS_MOUNT_SET_UID) {
>-					direntry->d_inode->i_uid = 
>+					direntry->d_inode->i_uid =
> 						current->fsuid;
>-					direntry->d_inode->i_gid = 
>+					direntry->d_inode->i_gid =
> 						current->fsgid;
> 				}
> 			}
> 		}
> 	}
>+mkdir_out:
> 	kfree(full_path);
> 	FreeXid(xid);
> 	return rc;
>@@ -849,10 +1094,10 @@ int cifs_rmdir(struct inode *inode, struct dentry *direntry)
> 			  cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
> 
> 	if (!rc) {
>-		inode->i_nlink--;
>+		drop_nlink(inode);
> 		spin_lock(&direntry->d_inode->i_lock);
>-		i_size_write(direntry->d_inode,0);
>-		direntry->d_inode->i_nlink = 0;
>+		i_size_write(direntry->d_inode, 0);
>+		clear_nlink(direntry->d_inode);
> 		spin_unlock(&direntry->d_inode->i_lock);
> 	}
> 
>@@ -914,9 +1159,9 @@ int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,
> 			kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
> 		if (info_buf_source != NULL) {
> 			info_buf_target = info_buf_source + 1;
>-			if (pTcon->ses->capabilities & CAP_UNIX)
>+			if (pTcon->unix_ext)
> 				rc = CIFSSMBUnixQPathInfo(xid, pTcon, fromName,
>-					info_buf_source, 
>+					info_buf_source,
> 					cifs_sb_source->local_nls,
> 					cifs_sb_source->mnt_cifs_flags &
> 						CIFS_MOUNT_MAP_SPECIAL_CHR);
>@@ -966,12 +1211,12 @@ int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,
> 		   might not right be right access to request */
> 		rc = CIFSSMBOpen(xid, pTcon, fromName, FILE_OPEN, GENERIC_READ,
> 				 CREATE_NOT_DIR, &netfid, &oplock, NULL,
>-				 cifs_sb_source->local_nls, 
>-				 cifs_sb_source->mnt_cifs_flags & 
>+				 cifs_sb_source->local_nls,
>+				 cifs_sb_source->mnt_cifs_flags &
> 					CIFS_MOUNT_MAP_SPECIAL_CHR);
>-		if (rc==0) {
>+		if (rc == 0) {
> 			rc = CIFSSMBRenameOpenFile(xid, pTcon, netfid, toName,
>-					      cifs_sb_source->local_nls, 
>+					      cifs_sb_source->local_nls,
> 					      cifs_sb_source->mnt_cifs_flags &
> 						CIFS_MOUNT_MAP_SPECIAL_CHR);
> 			CIFSSMBClose(xid, pTcon, netfid);
>@@ -1046,9 +1291,9 @@ int cifs_revalidate(struct dentry *direntry)
> 	local_mtime = direntry->d_inode->i_mtime;
> 	local_size = direntry->d_inode->i_size;
> 
>-	if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) {
>+	if (cifs_sb->tcon->unix_ext) {
> 		rc = cifs_get_inode_info_unix(&direntry->d_inode, full_path,
>-					      direntry->d_sb,xid);
>+					      direntry->d_sb, xid);
> 		if (rc) {
> 			cFYI(1, ("error on getting revalidate info %d", rc));
> /*			if (rc != -ENOENT)
>@@ -1057,7 +1302,7 @@ int cifs_revalidate(struct dentry *direntry)
> 		}
> 	} else {
> 		rc = cifs_get_inode_info(&direntry->d_inode, full_path, NULL,
>-					 direntry->d_sb,xid);
>+					 direntry->d_sb, xid);
> 		if (rc) {
> 			cFYI(1, ("error on getting revalidate info %d", rc));
> /*			if (rc != -ENOENT)
>@@ -1070,7 +1315,7 @@ int cifs_revalidate(struct dentry *direntry)
> 	/* if not oplocked, we invalidate inode pages if mtime or file size
> 	   had changed on server */
> 
>-	if (timespec_equal(&local_mtime,&direntry->d_inode->i_mtime) && 
>+	if (timespec_equal(&local_mtime, &direntry->d_inode->i_mtime) &&
> 	    (local_size == direntry->d_inode->i_size)) {
> 		cFYI(1, ("cifs_revalidate - inode unchanged"));
> 	} else {
>@@ -1097,7 +1342,7 @@ int cifs_revalidate(struct dentry *direntry)
> 	if (invalidate_inode) {
> 	/* shrink_dcache not necessary now that cifs dentry ops
> 	are exported for negative dentries */
>-/*		if(S_ISDIR(direntry->d_inode->i_mode)) 
>+/*		if (S_ISDIR(direntry->d_inode->i_mode))
> 			shrink_dcache_parent(direntry); */
> 		if (S_ISREG(direntry->d_inode->i_mode)) {
> 			if (direntry->d_inode->i_mapping)
>@@ -1112,7 +1357,7 @@ int cifs_revalidate(struct dentry *direntry)
> 		}
> 	}
> /*	mutex_unlock(&direntry->d_inode->i_mutex); */
>-	
>+
> 	kfree(full_path);
> 	FreeXid(xid);
> 	return rc;
>@@ -1156,7 +1401,7 @@ static int cifs_truncate_page(struct address_space *mapping, loff_t from)
> 	return rc;
> }
> 
>-static int cifs_vmtruncate(struct inode * inode, loff_t offset)
>+static int cifs_vmtruncate(struct inode *inode, loff_t offset)
> {
> 	struct address_space *mapping = inode->i_mapping;
> 	unsigned long limit;
>@@ -1174,12 +1419,25 @@ static int cifs_vmtruncate(struct inode * inode, loff_t offset)
> 	}
> 	i_size_write(inode, offset);
> 	spin_unlock(&inode->i_lock);
>+	/*
>+	 * unmap_mapping_range is called twice, first simply for efficiency
>+	 * so that truncate_inode_pages does fewer single-page unmaps. However
>+	 * after this first call, and before truncate_inode_pages finishes,
>+	 * it is possible for private pages to be COWed, which remain after
>+	 * truncate_inode_pages finishes, hence the second unmap_mapping_range
>+	 * call must be made for correctness.
>+	 */
> 	unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
> 	truncate_inode_pages(mapping, offset);
>+	unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
> 	goto out_truncate;
> 
> do_expand:
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 10)
>+	limit = current->rlim[RLIMIT_FSIZE].rlim_cur;
>+#else
> 	limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
>+#endif
> 	if (limit != RLIM_INFINITY && offset > limit) {
> 		spin_unlock(&inode->i_lock);
> 		goto out_sig;
>@@ -1229,13 +1487,13 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
> 	if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
> 		/* check if we have permission to change attrs */
> 		rc = inode_change_ok(direntry->d_inode, attrs);
>-		if(rc < 0) {
>+		if (rc < 0) {
> 			FreeXid(xid);
> 			return rc;
> 		} else
> 			rc = 0;
> 	}
>-		
>+
> 	full_path = build_path_from_dentry(direntry);
> 	if (full_path == NULL) {
> 		FreeXid(xid);
>@@ -1269,16 +1527,16 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
> 			rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size,
> 						nfid, npid, FALSE);
> 			atomic_dec(&open_file->wrtPending);
>-			cFYI(1,("SetFSize for attrs rc = %d", rc));
>-			if((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
>-				int bytes_written;
>+			cFYI(1, ("SetFSize for attrs rc = %d", rc));
>+			if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
>+				unsigned int bytes_written;
> 				rc = CIFSSMBWrite(xid, pTcon,
> 						  nfid, 0, attrs->ia_size,
> 						  &bytes_written, NULL, NULL,
> 						  1 /* 45 seconds */);
>-				cFYI(1,("Wrt seteof rc %d", rc));
>+				cFYI(1, ("Wrt seteof rc %d", rc));
> 			}
>-		} else 
>+		} else
> 			rc = -EINVAL;
> 
> 		if (rc != 0) {
>@@ -1288,11 +1546,11 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
> 			   it by handle */
> 			rc = CIFSSMBSetEOF(xid, pTcon, full_path,
> 					   attrs->ia_size, FALSE,
>-					   cifs_sb->local_nls, 
>+					   cifs_sb->local_nls,
> 					   cifs_sb->mnt_cifs_flags &
> 						CIFS_MOUNT_MAP_SPECIAL_CHR);
> 			cFYI(1, ("SetEOF by path (setattrs) rc = %d", rc));
>-			if((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
>+			if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
> 				__u16 netfid;
> 				int oplock = FALSE;
> 
>@@ -1303,14 +1561,14 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
> 					NULL, cifs_sb->local_nls,
> 					cifs_sb->mnt_cifs_flags &
> 						CIFS_MOUNT_MAP_SPECIAL_CHR);
>-				if (rc==0) {
>-					int bytes_written;
>+				if (rc == 0) {
>+					unsigned int bytes_written;
> 					rc = CIFSSMBWrite(xid, pTcon,
> 							netfid, 0,
> 							attrs->ia_size,
> 							&bytes_written, NULL,
> 							NULL, 1 /* 45 sec */);
>-					cFYI(1,("wrt seteof rc %d",rc));
>+					cFYI(1, ("wrt seteof rc %d", rc));
> 					CIFSSMBClose(xid, pTcon, netfid);
> 				}
> 
>@@ -1327,7 +1585,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
> 			rc = cifs_vmtruncate(direntry->d_inode, attrs->ia_size);
> 			cifs_truncate_page(direntry->d_inode->i_mapping,
> 					   direntry->d_inode->i_size);
>-		} else 
>+		} else
> 			goto cifs_setattr_exit;
> 	}
> 	if (attrs->ia_valid & ATTR_UID) {
>@@ -1345,11 +1603,11 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
> 		mode = attrs->ia_mode;
> 	}
> 
>-	if ((cifs_sb->tcon->ses->capabilities & CAP_UNIX)
>+	if ((pTcon->unix_ext)
> 	    && (attrs->ia_valid & (ATTR_MODE | ATTR_GID | ATTR_UID)))
> 		rc = CIFSSMBUnixSetPerms(xid, pTcon, full_path, mode, uid, gid,
> 					 0 /* dev_t */, cifs_sb->local_nls,
>-					 cifs_sb->mnt_cifs_flags & 
>+					 cifs_sb->mnt_cifs_flags &
> 						CIFS_MOUNT_MAP_SPECIAL_CHR);
> 	else if (attrs->ia_valid & ATTR_MODE) {
> 		rc = 0;
>@@ -1360,17 +1618,17 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
> 					cpu_to_le32(cifsInode->cifsAttrs |
> 						    ATTR_READONLY);
> 			}
>-		} else if ((mode & S_IWUGO) == S_IWUGO) {
>-			if (cifsInode->cifsAttrs & ATTR_READONLY) {
>-				set_dosattr = TRUE;
>-				time_buf.Attributes =
>-					cpu_to_le32(cifsInode->cifsAttrs &
>-						    (~ATTR_READONLY));
>-				/* Windows ignores set to zero */
>-				if(time_buf.Attributes == 0)
>-					time_buf.Attributes |= 
>-						cpu_to_le32(ATTR_NORMAL);
>-			}
>+		} else if (cifsInode->cifsAttrs & ATTR_READONLY) {
>+			/* If file is readonly on server, we would
>+			not be able to write to it - so if any write
>+			bit is enabled for user or group or other we
>+			need to at least try to remove r/o dos attr */
>+			set_dosattr = TRUE;
>+			time_buf.Attributes = cpu_to_le32(cifsInode->cifsAttrs &
>+					    (~ATTR_READONLY));
>+			/* Windows ignores set to zero */
>+			if (time_buf.Attributes == 0)
>+				time_buf.Attributes |= cpu_to_le32(ATTR_NORMAL);
> 		}
> 		/* BB to be implemented -
> 		   via Windows security descriptors or streams */
>@@ -1395,7 +1653,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
> 	   stamps are changed explicitly (i.e. by utime()
> 	   since we would then have a mix of client and
> 	   server times */
>-	   
>+
> 	if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
> 		set_time = TRUE;
> 		/* Although Samba throws this field away
>@@ -1434,7 +1692,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
> 					 NULL, cifs_sb->local_nls,
> 					 cifs_sb->mnt_cifs_flags &
> 						CIFS_MOUNT_MAP_SPECIAL_CHR);
>-			if (rc==0) {
>+			if (rc == 0) {
> 				rc = CIFSSMBSetFileTimes(xid, pTcon, &time_buf,
> 							 netfid);
> 				CIFSSMBClose(xid, pTcon, netfid);
>@@ -1444,7 +1702,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
> 			   granularity */
> 
> 			/* rc = CIFSSMBSetTimesLegacy(xid, pTcon, full_path,
>-        	        		&time_buf, cifs_sb->local_nls); */
>+					&time_buf, cifs_sb->local_nls); */
> 			}
> 		}
> 		/* Even if error on time set, no sense failing the call if
>@@ -1452,7 +1710,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
> 		and this check ensures that we are not being called from
> 		sys_utimes in which case we ought to fail the call back to
> 		the user when the server rejects the call */
>-		if((rc) && (attrs->ia_valid &
>+		if ((rc) && (attrs->ia_valid &
> 			 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
> 			rc = 0;
> 	}
>diff --git a/fs/cifs/ioctl.c b/fs/cifs/ioctl.c
>index b0ea668..f36733f 100644
>--- a/fs/cifs/ioctl.c
>+++ b/fs/cifs/ioctl.c
>@@ -3,7 +3,7 @@
>  *
>  *   vfs operations that deal with io control
>  *
>- *   Copyright (C) International Business Machines  Corp., 2005
>+ *   Copyright (C) International Business Machines  Corp., 2005,2007
>  *   Author(s): Steve French (sfrench@us.ibm.com)
>  *
>  *   This library is free software; you can redistribute it and/or modify
>@@ -22,7 +22,6 @@
>  */
> 
> #include <linux/fs.h>
>-#include <linux/ext2_fs.h>
> #include "cifspdu.h"
> #include "cifsglob.h"
> #include "cifsproto.h"
>@@ -30,8 +29,17 @@
> #include "cifsfs.h"
> 
> #define CIFS_IOC_CHECKUMOUNT _IO(0xCF, 2)
>+#ifndef FS_IOC_GETFLAGS
>+#define FS_IOC_GETFLAGS                 _IOR('f', 1, long)
>+#endif
>+#ifndef FS_IOC_SETFLAGS
>+#define FS_IOC_SETFLAGS                 _IOW('f', 2, long)
>+#endif
>+#ifndef FS_FL_USER_VISIBLE
>+#define FS_FL_USER_VISIBLE              0x0003DFFF /* User visible flags */
>+#endif
> 
>-int cifs_ioctl (struct inode * inode, struct file * filep, 
>+int cifs_ioctl (struct inode *inode, struct file *filep,
> 		unsigned int command, unsigned long arg)
> {
> 	int rc = -ENOTTY; /* strange error - but the precedent */
>@@ -48,13 +56,13 @@ int cifs_ioctl (struct inode * inode, struct file * filep,
> 
> 	xid = GetXid();
> 
>-        cFYI(1,("ioctl file %p  cmd %u  arg %lu",filep,command,arg));
>+	cFYI(1, ("ioctl file %p  cmd %u  arg %lu", filep, command, arg));
> 
> 	cifs_sb = CIFS_SB(inode->i_sb);
> 
> #ifdef CONFIG_CIFS_POSIX
> 	tcon = cifs_sb->tcon;
>-	if(tcon)
>+	if (tcon)
> 		caps = le64_to_cpu(tcon->fsUnixInfo.Capability);
> 	else {
> 		rc = -EIO;
>@@ -63,33 +71,33 @@ int cifs_ioctl (struct inode * inode, struct file * filep,
> 	}
> #endif /* CONFIG_CIFS_POSIX */
> 
>-	switch(command) {
>+	switch (command) {
> 		case CIFS_IOC_CHECKUMOUNT:
>-			cFYI(1,("User unmount attempted"));
>-			if(cifs_sb->mnt_uid == current->uid)
>+			cFYI(1, ("User unmount attempted"));
>+			if (cifs_sb->mnt_uid == current->uid)
> 				rc = 0;
> 			else {
> 				rc = -EACCES;
>-				cFYI(1,("uids do not match"));
>+				cFYI(1, ("uids do not match"));
> 			}
> 			break;
> #ifdef CONFIG_CIFS_POSIX
>-		case EXT2_IOC_GETFLAGS:
>-			if(CIFS_UNIX_EXTATTR_CAP & caps) {
>+		case FS_IOC_GETFLAGS:
>+			if (CIFS_UNIX_EXTATTR_CAP & caps) {
> 				if (pSMBFile == NULL)
> 					break;
> 				rc = CIFSGetExtAttr(xid, tcon, pSMBFile->netfid,
> 					&ExtAttrBits, &ExtAttrMask);
>-				if(rc == 0)
>+				if (rc == 0)
> 					rc = put_user(ExtAttrBits &
>-						EXT2_FL_USER_VISIBLE,
>+						FS_FL_USER_VISIBLE,
> 						(int __user *)arg);
> 			}
> 			break;
> 
>-		case EXT2_IOC_SETFLAGS:
>-			if(CIFS_UNIX_EXTATTR_CAP & caps) {
>-				if(get_user(ExtAttrBits,(int __user *)arg)) {
>+		case FS_IOC_SETFLAGS:
>+			if (CIFS_UNIX_EXTATTR_CAP & caps) {
>+				if (get_user(ExtAttrBits, (int __user *)arg)) {
> 					rc = -EFAULT;
> 					break;
> 				}
>@@ -97,16 +105,15 @@ int cifs_ioctl (struct inode * inode, struct file * filep,
> 					break;
> 				/* rc= CIFSGetExtAttr(xid,tcon,pSMBFile->netfid,
> 					extAttrBits, &ExtAttrMask);*/
>-				
> 			}
>-			cFYI(1,("set flags not implemented yet"));
>+			cFYI(1, ("set flags not implemented yet"));
> 			break;
> #endif /* CONFIG_CIFS_POSIX */
> 		default:
>-			cFYI(1,("unsupported ioctl"));
>+			cFYI(1, ("unsupported ioctl"));
> 			break;
> 	}
> 
> 	FreeXid(xid);
> 	return rc;
>-} 
>+}
>diff --git a/fs/cifs/link.c b/fs/cifs/link.c
>index 6fbba03..f161af7 100644
>--- a/fs/cifs/link.c
>+++ b/fs/cifs/link.c
>@@ -53,32 +53,33 @@ cifs_hardlink(struct dentry *old_file, struct inode *inode,
> 
> 	fromName = build_path_from_dentry(old_file);
> 	toName = build_path_from_dentry(direntry);
>-	if((fromName == NULL) || (toName == NULL)) {
>+	if ((fromName == NULL) || (toName == NULL)) {
> 		rc = -ENOMEM;
> 		goto cifs_hl_exit;
> 	}
> 
>-	if (cifs_sb_target->tcon->ses->capabilities & CAP_UNIX)
>+/*	if (cifs_sb_target->tcon->ses->capabilities & CAP_UNIX)*/
>+	if (pTcon->unix_ext)
> 		rc = CIFSUnixCreateHardLink(xid, pTcon, fromName, toName,
>-					    cifs_sb_target->local_nls, 
>+					    cifs_sb_target->local_nls,
> 					    cifs_sb_target->mnt_cifs_flags &
> 						CIFS_MOUNT_MAP_SPECIAL_CHR);
> 	else {
> 		rc = CIFSCreateHardLink(xid, pTcon, fromName, toName,
>-					cifs_sb_target->local_nls, 
>+					cifs_sb_target->local_nls,
> 					cifs_sb_target->mnt_cifs_flags &
> 						CIFS_MOUNT_MAP_SPECIAL_CHR);
>-		if((rc == -EIO) || (rc == -EINVAL))
>-			rc = -EOPNOTSUPP;  
>+		if ((rc == -EIO) || (rc == -EINVAL))
>+			rc = -EOPNOTSUPP;
> 	}
> 
> 	d_drop(direntry);	/* force new lookup from server of target */
> 
> 	/* if source file is cached (oplocked) revalidate will not go to server
> 	   until the file is closed or oplock broken so update nlinks locally */
>-	if(old_file->d_inode) {
>+	if (old_file->d_inode) {
> 		cifsInode = CIFS_I(old_file->d_inode);
>-		if(rc == 0) {
>+		if (rc == 0) {
> 			old_file->d_inode->i_nlink++;
> /* BB should we make this contingent on superblock flag NOATIME? */
> /*			old_file->d_inode->i_ctime = CURRENT_TIME;*/
>@@ -87,14 +88,14 @@ cifs_hardlink(struct dentry *old_file, struct inode *inode,
> 			to set the parent dir cifs inode time to zero
> 			to force revalidate (faster) for it too? */
> 		}
>-		/* if not oplocked will force revalidate to get info 
>+		/* if not oplocked will force revalidate to get info
> 		   on source file from srv */
> 		cifsInode->time = 0;
> 
>-                /* Will update parent dir timestamps from srv within a second.
>+		/* Will update parent dir timestamps from srv within a second.
> 		   Would it really be worth it to set the parent dir (cifs
> 		   inode) time field to zero to force revalidate on parent
>-		   directory faster ie 
>+		   directory faster ie
> 			CIFS_I(inode)->time = 0;  */
> 	}
> 
>@@ -116,7 +117,7 @@ cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
> 	int rc = -EACCES;
> 	int xid;
> 	char *full_path = NULL;
>-	char * target_path = ERR_PTR(-ENOMEM);
>+	char *target_path = ERR_PTR(-ENOMEM);
> 	struct cifs_sb_info *cifs_sb;
> 	struct cifsTconInfo *pTcon;
> 
>@@ -136,13 +137,19 @@ cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
> 		goto out;
> 	}
> 
>-/* BB add read reparse point symlink code and Unix extensions symlink code here BB */
>+	/* We could change this to:
>+		if (pTcon->unix_ext)
>+	   but there does not seem any point in refusing to
>+	   get symlink info if we can, even if unix extensions
>+	   turned off for this mount */
>+
> 	if (pTcon->ses->capabilities & CAP_UNIX)
> 		rc = CIFSSMBUnixQuerySymLink(xid, pTcon, full_path,
> 					     target_path,
> 					     PATH_MAX-1,
> 					     cifs_sb->local_nls);
> 	else {
>+		/* BB add read reparse point symlink code here */
> 		/* rc = CIFSSMBQueryReparseLinkInfo */
> 		/* BB Add code to Query ReparsePoint info */
> 		/* BB Add MAC style xsymlink check here if enabled */
>@@ -192,7 +199,7 @@ cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
> 
> 	full_path = build_path_from_dentry(direntry);
> 
>-	if(full_path == NULL) {
>+	if (full_path == NULL) {
> 		FreeXid(xid);
> 		return -ENOMEM;
> 	}
>@@ -201,19 +208,20 @@ cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
> 	cFYI(1, ("symname is %s", symname));
> 
> 	/* BB what if DFS and this volume is on different share? BB */
>-	if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)
>+	if (pTcon->unix_ext)
> 		rc = CIFSUnixCreateSymLink(xid, pTcon, full_path, symname,
> 					   cifs_sb->local_nls);
> 	/* else
>-	   rc = CIFSCreateReparseSymLink(xid, pTcon, fromName, toName,cifs_sb_target->local_nls); */
>+	   rc = CIFSCreateReparseSymLink(xid, pTcon, fromName, toName,
>+					cifs_sb_target->local_nls); */
> 
> 	if (rc == 0) {
>-		if (pTcon->ses->capabilities & CAP_UNIX)
>+		if (pTcon->unix_ext)
> 			rc = cifs_get_inode_info_unix(&newinode, full_path,
>-						      inode->i_sb,xid);
>+						      inode->i_sb, xid);
> 		else
> 			rc = cifs_get_inode_info(&newinode, full_path, NULL,
>-						 inode->i_sb,xid);
>+						 inode->i_sb, xid);
> 
> 		if (rc != 0) {
> 			cFYI(1, ("Create symlink ok, getinodeinfo fail rc = %d",
>@@ -242,10 +250,10 @@ cifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen)
> 	struct cifs_sb_info *cifs_sb;
> 	struct cifsTconInfo *pTcon;
> 	char *full_path = NULL;
>-	char *tmp_path =  NULL;
>-	char * tmpbuffer;
>-	unsigned char * referrals = NULL;
>-	int num_referrals = 0;
>+	char *tmp_path = NULL;
>+	char *tmpbuffer;
>+	unsigned char *referrals = NULL;
>+	unsigned int num_referrals = 0;
> 	int len;
> 	__u16 fid;
> 
>@@ -253,13 +261,13 @@ cifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen)
> 	cifs_sb = CIFS_SB(inode->i_sb);
> 	pTcon = cifs_sb->tcon;
> 
>-/* BB would it be safe against deadlock to grab this sem 
>+/* BB would it be safe against deadlock to grab this sem
>       even though rename itself grabs the sem and calls lookup? */
>-/*       down(&inode->i_sb->s_vfs_rename_sem);*/
>+/*       mutex_lock(&inode->i_sb->s_vfs_rename_mutex);*/
> 	full_path = build_path_from_dentry(direntry);
>-/*       up(&inode->i_sb->s_vfs_rename_sem);*/
>+/*       mutex_unlock(&inode->i_sb->s_vfs_rename_mutex);*/
> 
>-	if(full_path == NULL) {
>+	if (full_path == NULL) {
> 		FreeXid(xid);
> 		return -ENOMEM;
> 	}
>@@ -267,70 +275,80 @@ cifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen)
> 	cFYI(1,
> 	     ("Full path: %s inode = 0x%p pBuffer = 0x%p buflen = %d",
> 	      full_path, inode, pBuffer, buflen));
>-	if(buflen > PATH_MAX)
>+	if (buflen > PATH_MAX)
> 		len = PATH_MAX;
> 	else
> 		len = buflen;
>-	tmpbuffer = kmalloc(len,GFP_KERNEL);   
>-	if(tmpbuffer == NULL) {
>+	tmpbuffer = kmalloc(len, GFP_KERNEL);
>+	if (tmpbuffer == NULL) {
> 		kfree(full_path);
> 		FreeXid(xid);
> 		return -ENOMEM;
> 	}
> 
>-/* BB add read reparse point symlink code and Unix extensions symlink code here BB */
>+/* BB add read reparse point symlink code and
>+	Unix extensions symlink code here BB */
>+/* We could disable this based on pTcon->unix_ext flag instead ... but why? */
> 	if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)
> 		rc = CIFSSMBUnixQuerySymLink(xid, pTcon, full_path,
> 				tmpbuffer,
> 				len - 1,
> 				cifs_sb->local_nls);
> 	else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
>-		cERROR(1,("SFU style symlinks not implemented yet"));
>+		cERROR(1, ("SFU style symlinks not implemented yet"));
> 		/* add open and read as in fs/cifs/inode.c */
>-	
> 	} else {
> 		rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, GENERIC_READ,
>-				OPEN_REPARSE_POINT,&fid, &oplock, NULL, 
>-				cifs_sb->local_nls, 
>-				cifs_sb->mnt_cifs_flags & 
>+				OPEN_REPARSE_POINT, &fid, &oplock, NULL,
>+				cifs_sb->local_nls,
>+				cifs_sb->mnt_cifs_flags &
> 					CIFS_MOUNT_MAP_SPECIAL_CHR);
>-		if(!rc) {
>+		if (!rc) {
> 			rc = CIFSSMBQueryReparseLinkInfo(xid, pTcon, full_path,
> 				tmpbuffer,
>-				len - 1, 
>+				len - 1,
> 				fid,
> 				cifs_sb->local_nls);
>-			if(CIFSSMBClose(xid, pTcon, fid)) {
>-				cFYI(1,("Error closing junction point (open for ioctl)"));
>+			if (CIFSSMBClose(xid, pTcon, fid)) {
>+				cFYI(1, ("Error closing junction point "
>+					 "(open for ioctl)"));
> 			}
>-			if(rc == -EIO) {
>+			if (rc == -EIO) {
> 				/* Query if DFS Junction */
> 				tmp_path =
> 					kmalloc(MAX_TREE_SIZE + MAX_PATHCONF + 1,
> 						GFP_KERNEL);
> 				if (tmp_path) {
>-					strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);
>-					strncat(tmp_path, full_path, MAX_PATHCONF);
>-					rc = get_dfs_path(xid, pTcon->ses, tmp_path,
>+					strncpy(tmp_path, pTcon->treeName,
>+						MAX_TREE_SIZE);
>+					strncat(tmp_path, full_path,
>+						MAX_PATHCONF);
>+					rc = get_dfs_path(xid, pTcon->ses,
>+						tmp_path,
> 						cifs_sb->local_nls,
> 						&num_referrals, &referrals,
> 						cifs_sb->mnt_cifs_flags &
> 						    CIFS_MOUNT_MAP_SPECIAL_CHR);
>-					cFYI(1,("Get DFS for %s rc = %d ",tmp_path, rc));
>-					if((num_referrals == 0) && (rc == 0))
>+					cFYI(1, ("Get DFS for %s rc = %d ",
>+						tmp_path, rc));
>+					if ((num_referrals == 0) && (rc == 0))
> 						rc = -EACCES;
> 					else {
>-						cFYI(1,("num referral: %d",num_referrals));
>-						if(referrals) {
>-							cFYI(1,("referral string: %s",referrals));
>-							strncpy(tmpbuffer, referrals, len-1);                            
>+						cFYI(1, ("num referral: %d",
>+							num_referrals));
>+						if (referrals) {
>+							cFYI(1,("referral string: %s", referrals));
>+							strncpy(tmpbuffer,
>+								referrals,
>+								len-1);
> 						}
> 					}
> 					kfree(referrals);
> 					kfree(tmp_path);
> }
>-				/* BB add code like else decode referrals then memcpy to
>-				  tmpbuffer and free referrals string array BB */
>+				/* BB add code like else decode referrals
>+				then memcpy to tmpbuffer and free referrals
>+				string array BB */
> 			}
> 		}
> 	}
>diff --git a/fs/cifs/md4.c b/fs/cifs/md4.c
>index 46d62c9..a2415c1 100644
>--- a/fs/cifs/md4.c
>+++ b/fs/cifs/md4.c
>@@ -1,20 +1,20 @@
>-/* 
>+/*
>    Unix SMB/Netbios implementation.
>    Version 1.9.
>    a implementation of MD4 designed for use in the SMB authentication protocol
>    Copyright (C) Andrew Tridgell 1997-1998.
>    Modified by Steve French (sfrench@us.ibm.com) 2002-2003
>-   
>+
>    This program is free software; you can redistribute it and/or modify
>    it under the terms of the GNU General Public License as published by
>    the Free Software Foundation; either version 2 of the License, or
>    (at your option) any later version.
>-   
>+
>    This program is distributed in the hope that it will be useful,
>    but WITHOUT ANY WARRANTY; without even the implied warranty of
>    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>    GNU General Public License for more details.
>-   
>+
>    You should have received a copy of the GNU General Public License
>    along with this program; if not, write to the Free Software
>    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
>@@ -170,7 +170,7 @@ mdfour(unsigned char *out, unsigned char *in, int n)
> 
> 	while (n > 64) {
> 		copy64(M, in);
>-		mdfour64(M,&A,&B, &C, &D);
>+		mdfour64(M, &A, &B, &C, &D);
> 		in += 64;
> 		n -= 64;
> 	}
>diff --git a/fs/cifs/md5.c b/fs/cifs/md5.c
>index 7aa2349..e5c3e12 100644
>--- a/fs/cifs/md5.c
>+++ b/fs/cifs/md5.c
>@@ -15,9 +15,9 @@
>  * will fill a supplied 16-byte array with the digest.
>  */
> 
>-/* This code slightly modified to fit into Samba by 
>-   abartlet@samba.org Jun 2001 
>-   and to fit the cifs vfs by 
>+/* This code slightly modified to fit into Samba by
>+   abartlet@samba.org Jun 2001
>+   and to fit the cifs vfs by
>    Steve French sfrench@us.ibm.com */
> 
> #include <linux/string.h>
>@@ -106,7 +106,7 @@ MD5Update(struct MD5Context *ctx, unsigned char const *buf, unsigned len)
> }
> 
> /*
>- * Final wrapup - pad to 64-byte boundary with the bit pattern 
>+ * Final wrapup - pad to 64-byte boundary with the bit pattern
>  * 1 0* (64-bit count of bits processed, MSB-first)
>  */
> void
>@@ -252,10 +252,11 @@ MD5Transform(__u32 buf[4], __u32 const in[16])
> 	buf[3] += d;
> }
> 
>+#if 0   /* currently unused */
> /***********************************************************************
>  the rfc 2104 version of hmac_md5 initialisation.
> ***********************************************************************/
>-void
>+static void
> hmac_md5_init_rfc2104(unsigned char *key, int key_len,
> 		      struct HMACMD5Context *ctx)
> {
>@@ -289,6 +290,7 @@ hmac_md5_init_rfc2104(unsigned char *key, int key_len,
> 	MD5Init(&ctx->ctx);
> 	MD5Update(&ctx->ctx, ctx->k_ipad, 64);
> }
>+#endif
> 
> /***********************************************************************
>  the microsoft version of hmac_md5 initialisation.
>@@ -350,7 +352,8 @@ hmac_md5_final(unsigned char *digest, struct HMACMD5Context *ctx)
>  single function to calculate an HMAC MD5 digest from data.
>  use the microsoft hmacmd5 init method because the key is 16 bytes.
> ************************************************************/
>-void
>+#if 0 /* currently unused */
>+static void
> hmac_md5(unsigned char key[16], unsigned char *data, int data_len,
> 	 unsigned char *digest)
> {
>@@ -361,3 +364,4 @@ hmac_md5(unsigned char key[16], unsigned char *data, int data_len,
> 	}
> 	hmac_md5_final(digest, &ctx);
> }
>+#endif
>diff --git a/fs/cifs/md5.h b/fs/cifs/md5.h
>index 00e1c53..f7d4f41 100644
>--- a/fs/cifs/md5.h
>+++ b/fs/cifs/md5.h
>@@ -27,12 +27,12 @@ void MD5Final(unsigned char digest[16], struct MD5Context *context);
> 
> /* The following definitions come from lib/hmacmd5.c  */
> 
>-void hmac_md5_init_rfc2104(unsigned char *key, int key_len,
>-			struct HMACMD5Context *ctx);
>+/* void hmac_md5_init_rfc2104(unsigned char *key, int key_len,
>+			struct HMACMD5Context *ctx);*/
> void hmac_md5_init_limK_to_64(const unsigned char *key, int key_len,
> 			struct HMACMD5Context *ctx);
> void hmac_md5_update(const unsigned char *text, int text_len,
> 			struct HMACMD5Context *ctx);
> void hmac_md5_final(unsigned char *digest, struct HMACMD5Context *ctx);
>-void hmac_md5(unsigned char key[16], unsigned char *data, int data_len,
>-			unsigned char *digest);
>+/* void hmac_md5(unsigned char key[16], unsigned char *data, int data_len,
>+			unsigned char *digest);*/
>diff --git a/fs/cifs/misc.c b/fs/cifs/misc.c
>index e5e544d..0b132fb 100644
>--- a/fs/cifs/misc.c
>+++ b/fs/cifs/misc.c
>@@ -1,7 +1,7 @@
> /*
>  *   fs/cifs/misc.c
>  *
>- *   Copyright (C) International Business Machines  Corp., 2002,2005
>+ *   Copyright (C) International Business Machines  Corp., 2002,2007
>  *   Author(s): Steve French (sfrench@us.ibm.com)
>  *
>  *   This library is free software; you can redistribute it and/or modify
>@@ -16,7 +16,7 @@
>  *
>  *   You should have received a copy of the GNU Lesser General Public License
>  *   along with this library; if not, write to the Free Software
>- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
>+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>  */
> 
> #include <linux/slab.h>
>@@ -40,12 +40,12 @@ extern mempool_t *cifs_req_poolp;
> extern kmem_cache_t *cifs_sm_req_cachep;
> extern kmem_cache_t *cifs_req_cachep;
> #endif
>-extern struct task_struct * oplockThread;
>+extern struct task_struct *oplockThread;
> 
>-/* The xid serves as a useful identifier for each incoming vfs request, 
>-   in a similar way to the mid which is useful to track each sent smb, 
>-   and CurrentXid can also provide a running counter (although it 
>-   will eventually wrap past zero) of the total vfs operations handled 
>+/* The xid serves as a useful identifier for each incoming vfs request,
>+   in a similar way to the mid which is useful to track each sent smb,
>+   and CurrentXid can also provide a running counter (although it
>+   will eventually wrap past zero) of the total vfs operations handled
>    since the cifs fs was mounted */
> 
> unsigned int
>@@ -55,10 +55,12 @@ _GetXid(void)
> 
> 	spin_lock(&GlobalMid_Lock);
> 	GlobalTotalActiveXid++;
>+
>+	/* keep high water mark for number of simultaneous ops in filesystem */
> 	if (GlobalTotalActiveXid > GlobalMaxActiveXid)
>-		GlobalMaxActiveXid = GlobalTotalActiveXid;	/* keep high water mark for number of simultaneous vfs ops in our filesystem */
>-	if(GlobalTotalActiveXid > 65000)
>-		cFYI(1,("warning: more than 65000 requests active"));
>+		GlobalMaxActiveXid = GlobalTotalActiveXid;
>+	if (GlobalTotalActiveXid > 65000)
>+		cFYI(1, ("warning: more than 65000 requests active"));
> 	xid = GlobalCurrentXid++;
> 	spin_unlock(&GlobalMid_Lock);
> 	return xid;
>@@ -68,7 +70,7 @@ void
> _FreeXid(unsigned int xid)
> {
> 	spin_lock(&GlobalMid_Lock);
>-	/* if(GlobalTotalActiveXid == 0)
>+	/* if (GlobalTotalActiveXid == 0)
> 		BUG(); */
> 	GlobalTotalActiveXid--;
> 	spin_unlock(&GlobalMid_Lock);
>@@ -152,17 +154,17 @@ cifs_buf_get(void)
> {
> 	struct smb_hdr *ret_buf = NULL;
> 
>-/* We could use negotiated size instead of max_msgsize - 
>-   but it may be more efficient to always alloc same size 
>-   albeit slightly larger than necessary and maxbuffersize 
>+/* We could use negotiated size instead of max_msgsize -
>+   but it may be more efficient to always alloc same size
>+   albeit slightly larger than necessary and maxbuffersize
>    defaults to this and can not be bigger */
>-	ret_buf =
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
>-	    (struct smb_hdr *) mempool_alloc(cifs_req_poolp, SLAB_KERNEL | SLAB_NOFS);
>+	ret_buf = (struct smb_hdr *) mempool_alloc(cifs_req_poolp,
>+						   GFP_KERNEL | GFP_NOFS);
> #else
>-	    (struct smb_hdr *) kmem_cache_alloc(cifs_req_cachep, SLAB_KERNEL);
>+	ret_buf = (struct smb_hdr *) kmem_cache_alloc(cifs_req_cachep, 
>+						   SLAB_KERNEL);
> #endif
>-
> 	/* clear the first few header bytes */
> 	/* for most paths, more is cleared in header_assemble */
> 	if (ret_buf) {
>@@ -185,10 +187,11 @@ cifs_buf_release(void *buf_to_free)
> 		return;
> 	}
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
>-	mempool_free(buf_to_free,cifs_req_poolp);
>+	mempool_free(buf_to_free, cifs_req_poolp);
> #else
> 	kmem_cache_free(cifs_req_cachep, buf_to_free);
> #endif
>+
> 	atomic_dec(&bufAllocCount);
> 	return;
> }
>@@ -198,15 +201,16 @@ cifs_small_buf_get(void)
> {
> 	struct smb_hdr *ret_buf = NULL;
> 
>-/* We could use negotiated size instead of max_msgsize - 
>-   but it may be more efficient to always alloc same size 
>-   albeit slightly larger than necessary and maxbuffersize 
>+/* We could use negotiated size instead of max_msgsize -
>+   but it may be more efficient to always alloc same size
>+   albeit slightly larger than necessary and maxbuffersize
>    defaults to this and can not be bigger */
>-	ret_buf =
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
>-	    (struct smb_hdr *) mempool_alloc(cifs_sm_req_poolp, SLAB_KERNEL | SLAB_NOFS);
>+	ret_buf = (struct smb_hdr *) mempool_alloc(cifs_sm_req_poolp,
>+						   GFP_KERNEL | GFP_NOFS);
> #else
>-	    (struct smb_hdr *) kmem_cache_alloc(cifs_sm_req_cachep, SLAB_KERNEL);
>+	ret_buf = (struct smb_hdr *) kmem_cache_alloc(cifs_sm_req_cachep,
>+						   SLAB_KERNEL);
> #endif
> 	if (ret_buf) {
> 	/* No need to clear memory here, cleared in header assemble */
>@@ -229,7 +233,7 @@ cifs_small_buf_release(void *buf_to_free)
> 		return;
> 	}
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
>-	mempool_free(buf_to_free,cifs_sm_req_poolp);
>+	mempool_free(buf_to_free, cifs_sm_req_poolp);
> #else
> 	kmem_cache_free(cifs_sm_req_cachep, buf_to_free);
> #endif
>@@ -238,24 +242,24 @@ cifs_small_buf_release(void *buf_to_free)
> 	return;
> }
> 
>-/* 
>+/*
> 	Find a free multiplex id (SMB mid). Otherwise there could be
> 	mid collisions which might cause problems, demultiplexing the
> 	wrong response to this request. Multiplex ids could collide if
> 	one of a series requests takes much longer than the others, or
> 	if a very large number of long lived requests (byte range
> 	locks or FindNotify requests) are pending.  No more than
>-	64K-1 requests can be outstanding at one time.  If no 
>+	64K-1 requests can be outstanding at one time.  If no
> 	mids are available, return zero.  A future optimization
> 	could make the combination of mids and uid the key we use
>-	to demultiplex on (rather than mid alone).  
>+	to demultiplex on (rather than mid alone).
> 	In addition to the above check, the cifs demultiplex
> 	code already used the command code as a secondary
> 	check of the frame and if signing is negotiated the
> 	response would be discarded if the mid were the same
> 	but the signature was wrong.  Since the mid is not put in the
> 	pending queue until later (when it is about to be dispatched)
>-	we do have to limit the number of outstanding requests 
>+	we do have to limit the number of outstanding requests
> 	to somewhat less than 64K-1 although it is hard to imagine
> 	so many threads being in the vfs at one time.
> */
>@@ -263,27 +267,27 @@ __u16 GetNextMid(struct TCP_Server_Info *server)
> {
> 	__u16 mid = 0;
> 	__u16 last_mid;
>-	int   collision;  
>+	int   collision;
> 
>-	if(server == NULL)
>+	if (server == NULL)
> 		return mid;
> 
> 	spin_lock(&GlobalMid_Lock);
> 	last_mid = server->CurrentMid; /* we do not want to loop forever */
> 	server->CurrentMid++;
> 	/* This nested loop looks more expensive than it is.
>-	In practice the list of pending requests is short, 
>+	In practice the list of pending requests is short,
> 	fewer than 50, and the mids are likely to be unique
> 	on the first pass through the loop unless some request
> 	takes longer than the 64 thousand requests before it
> 	(and it would also have to have been a request that
> 	 did not time out) */
>-	while(server->CurrentMid != last_mid) {
>+	while (server->CurrentMid != last_mid) {
> 		struct list_head *tmp;
> 		struct mid_q_entry *mid_entry;
> 
> 		collision = 0;
>-		if(server->CurrentMid == 0)
>+		if (server->CurrentMid == 0)
> 			server->CurrentMid++;
> 
> 		list_for_each(tmp, &server->pending_mid_q) {
>@@ -296,7 +300,7 @@ __u16 GetNextMid(struct TCP_Server_Info *server)
> 				break;
> 			}
> 		}
>-		if(collision == 0) {
>+		if (collision == 0) {
> 			mid = server->CurrentMid;
> 			break;
> 		}
>@@ -313,11 +317,11 @@ header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
> 		const struct cifsTconInfo *treeCon, int word_count
> 		/* length of fixed section (word count) in two byte units  */)
> {
>-	struct list_head* temp_item;
>-	struct cifsSesInfo * ses;
>+	struct list_head *temp_item;
>+	struct cifsSesInfo *ses;
> 	char *temp = (char *) buffer;
> 
>-	memset(temp,0,256); /* bigger than MAX_CIFS_HDR_SIZE */
>+	memset(temp, 0, 256); /* bigger than MAX_CIFS_HDR_SIZE */
> 
> 	buffer->smb_buf_length =
> 	    (2 * word_count) + sizeof (struct smb_hdr) -
>@@ -348,7 +352,7 @@ header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
> 			/* Uid is not converted */
> 			buffer->Uid = treeCon->ses->Suid;
> 			buffer->Mid = GetNextMid(treeCon->ses->server);
>-			if(multiuser_mount != 0) {
>+			if (multiuser_mount != 0) {
> 		/* For the multiuser case, there are few obvious technically  */
> 		/* possible mechanisms to match the local linux user (uid)    */
> 		/* to a valid remote smb user (smb_uid):		      */
>@@ -371,21 +375,22 @@ header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
> 		/* 	   flag were disabled.  */
> 
> 		/*  BB Add support for establishing new tCon and SMB Session  */
>-		/*      with userid/password pairs found on the smb session   */ 
>+		/*      with userid/password pairs found on the smb session   */
> 		/*	for other target tcp/ip addresses 		BB    */
>-				if(current->fsuid != treeCon->ses->linux_uid) {
>-					cFYI(1,("Multiuser mode and UID did not match tcon uid"));
>+				if (current->fsuid != treeCon->ses->linux_uid) {
>+					cFYI(1, ("Multiuser mode and UID "
>+						 "did not match tcon uid"));
> 					read_lock(&GlobalSMBSeslock);
> 					list_for_each(temp_item, &GlobalSMBSessionList) {
> 						ses = list_entry(temp_item, struct cifsSesInfo, cifsSessionList);
>-						if(ses->linux_uid == current->fsuid) {
>-							if(ses->server == treeCon->ses->server) {
>-								cFYI(1,("found matching uid substitute right smb_uid"));  
>+						if (ses->linux_uid == current->fsuid) {
>+							if (ses->server == treeCon->ses->server) {
>+								cFYI(1, ("found matching uid substitute right smb_uid"));
> 								buffer->Uid = ses->Suid;
> 								break;
> 							} else {
>-								/* BB eventually call cifs_setup_session here */
>-								cFYI(1,("local UID found but smb sess with this server does not exist"));  
>+				/* BB eventually call cifs_setup_session here */
>+								cFYI(1, ("local UID found but no smb sess with this server exists"));
> 							}
> 						}
> 					}
>@@ -397,8 +402,8 @@ header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
> 			buffer->Flags2 |= SMBFLG2_DFS;
> 		if (treeCon->nocase)
> 			buffer->Flags  |= SMBFLG_CASELESS;
>-		if((treeCon->ses) && (treeCon->ses->server))
>-			if(treeCon->ses->server->secMode & 
>+		if ((treeCon->ses) && (treeCon->ses->server))
>+			if (treeCon->ses->server->secMode &
> 			  (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
> 				buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
> 	}
>@@ -408,21 +413,21 @@ header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
> 	return;
> }
> 
>-int
>+static int
> checkSMBhdr(struct smb_hdr *smb, __u16 mid)
> {
>-	/* Make sure that this really is an SMB, that it is a response, 
>+	/* Make sure that this really is an SMB, that it is a response,
> 	   and that the message ids match */
>-	if ((*(__le32 *) smb->Protocol == cpu_to_le32(0x424d53ff)) && 
>-		(mid == smb->Mid)) {    
>-		if(smb->Flags & SMBFLG_RESPONSE)
>-			return 0;                    
>-		else {        
>+	if ((*(__le32 *) smb->Protocol == cpu_to_le32(0x424d53ff)) &&
>+		(mid == smb->Mid)) {
>+		if (smb->Flags & SMBFLG_RESPONSE)
>+			return 0;
>+		else {
> 		/* only one valid case where server sends us request */
>-			if(smb->Command == SMB_COM_LOCKING_ANDX)
>+			if (smb->Command == SMB_COM_LOCKING_ANDX)
> 				return 0;
> 			else
>-				cERROR(1, ("Rcvd Request not response"));         
>+				cERROR(1, ("Received Request not response"));
> 		}
> 	} else { /* bad signature or mid */
> 		if (*(__le32 *) smb->Protocol != cpu_to_le32(0x424d53ff))
>@@ -449,9 +454,9 @@ checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
> 			smb->WordCount = 0;
> 			/* some error cases do not return wct and bcc */
> 			return 0;
>-		} else if ((length == sizeof(struct smb_hdr) + 1) && 
>+		} else if ((length == sizeof(struct smb_hdr) + 1) &&
> 				(smb->WordCount == 0)) {
>-			char * tmp = (char *)smb;
>+			char *tmp = (char *)smb;
> 			/* Need to work around a bug in two servers here */
> 			/* First, check if the part of bcc they sent was zero */
> 			if (tmp[sizeof(struct smb_hdr)] == 0) {
>@@ -465,7 +470,7 @@ checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
> 				tmp[sizeof(struct smb_hdr)+1] = 0;
> 				return 0;
> 			}
>-			cERROR(1,("rcvd invalid byte count (bcc)"));
>+			cERROR(1, ("rcvd invalid byte count (bcc)"));
> 		} else {
> 			cERROR(1, ("Length less than smb header size"));
> 		}
>@@ -481,32 +486,33 @@ checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
> 		return 1;
> 	clc_len = smbCalcSize_LE(smb);
> 
>-	if(4 + len != length) {
>-		cERROR(1, ("Length read does not match RFC1001 length %d",len));
>+	if (4 + len != length) {
>+		cERROR(1, ("Length read does not match RFC1001 length %d",
>+			   len));
> 		return 1;
> 	}
> 
> 	if (4 + len != clc_len) {
> 		/* check if bcc wrapped around for large read responses */
>-		if((len > 64 * 1024) && (len > clc_len)) {
>+		if ((len > 64 * 1024) && (len > clc_len)) {
> 			/* check if lengths match mod 64K */
>-			if(((4 + len) & 0xFFFF) == (clc_len & 0xFFFF))
>-				return 0; /* bcc wrapped */			
>+			if (((4 + len) & 0xFFFF) == (clc_len & 0xFFFF))
>+				return 0; /* bcc wrapped */
> 		}
> 		cFYI(1, ("Calculated size %d vs length %d mismatch for mid %d",
> 				clc_len, 4 + len, smb->Mid));
> 		/* Windows XP can return a few bytes too much, presumably
>-		an illegal pad, at the end of byte range lock responses 
>+		an illegal pad, at the end of byte range lock responses
> 		so we allow for that three byte pad, as long as actual
> 		received length is as long or longer than calculated length */
>-		/* We have now had to extend this more, since there is a 
>+		/* We have now had to extend this more, since there is a
> 		case in which it needs to be bigger still to handle a
> 		malformed response to transact2 findfirst from WinXP when
> 		access denied is returned and thus bcc and wct are zero
> 		but server says length is 0x21 bytes too long as if the server
> 		forget to reset the smb rfc1001 length when it reset the
> 		wct and bcc to minimum size and drop the t2 parms and data */
>-		if((4+len > clc_len) && (len <= clc_len + 512))
>+		if ((4+len > clc_len) && (len <= clc_len + 512))
> 			return 0;
> 		else {
> 			cERROR(1, ("RFC1001 size %d bigger than SMB for Mid=%d",
>@@ -518,61 +524,64 @@ checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
> }
> int
> is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
>-{    
>-	struct smb_com_lock_req * pSMB = (struct smb_com_lock_req *)buf;
>+{
>+	struct smb_com_lock_req *pSMB = (struct smb_com_lock_req *)buf;
> 	struct list_head *tmp;
> 	struct list_head *tmp1;
> 	struct cifsTconInfo *tcon;
> 	struct cifsFileInfo *netfile;
> 
>-	cFYI(1,("Checking for oplock break or dnotify response"));
>-	if((pSMB->hdr.Command == SMB_COM_NT_TRANSACT) &&
>+	cFYI(1, ("Checking for oplock break or dnotify response"));
>+	if ((pSMB->hdr.Command == SMB_COM_NT_TRANSACT) &&
> 	   (pSMB->hdr.Flags & SMBFLG_RESPONSE)) {
>-		struct smb_com_transaction_change_notify_rsp * pSMBr =
>+		struct smb_com_transaction_change_notify_rsp *pSMBr =
> 			(struct smb_com_transaction_change_notify_rsp *)buf;
>-		struct file_notify_information * pnotify;
>+		struct file_notify_information *pnotify;
> 		__u32 data_offset = 0;
>-		if(pSMBr->ByteCount > sizeof(struct file_notify_information)) {
>+		if (pSMBr->ByteCount > sizeof(struct file_notify_information)) {
> 			data_offset = le32_to_cpu(pSMBr->DataOffset);
> 
> 			pnotify = (struct file_notify_information *)
> 				((char *)&pSMBr->hdr.Protocol + data_offset);
>-			cFYI(1,("dnotify on %s Action: 0x%x",pnotify->FileName,
>+			cFYI(1, ("dnotify on %s Action: 0x%x",
>+				 pnotify->FileName,
> 				pnotify->Action));  /* BB removeme BB */
>-	             /*   cifs_dump_mem("Rcvd notify Data: ",buf,
>+			/*   cifs_dump_mem("Rcvd notify Data: ",buf,
> 				sizeof(struct smb_hdr)+60); */
> 			return TRUE;
> 		}
>-		if(pSMBr->hdr.Status.CifsError) {
>-			cFYI(1,("notify err 0x%d",pSMBr->hdr.Status.CifsError));
>+		if (pSMBr->hdr.Status.CifsError) {
>+			cFYI(1, ("notify err 0x%d",
>+				pSMBr->hdr.Status.CifsError));
> 			return TRUE;
> 		}
> 		return FALSE;
>-	}  
>-	if(pSMB->hdr.Command != SMB_COM_LOCKING_ANDX)
>+	}
>+	if (pSMB->hdr.Command != SMB_COM_LOCKING_ANDX)
> 		return FALSE;
>-	if(pSMB->hdr.Flags & SMBFLG_RESPONSE) {
>+	if (pSMB->hdr.Flags & SMBFLG_RESPONSE) {
> 		/* no sense logging error on invalid handle on oplock
> 		   break - harmless race between close request and oplock
> 		   break response is expected from time to time writing out
> 		   large dirty files cached on the client */
>-		if ((NT_STATUS_INVALID_HANDLE) == 
>-		   le32_to_cpu(pSMB->hdr.Status.CifsError)) { 
>-			cFYI(1,("invalid handle on oplock break"));
>+		if ((NT_STATUS_INVALID_HANDLE) ==
>+		   le32_to_cpu(pSMB->hdr.Status.CifsError)) {
>+			cFYI(1, ("invalid handle on oplock break"));
> 			return TRUE;
>-		} else if (ERRbadfid == 
>+		} else if (ERRbadfid ==
> 		   le16_to_cpu(pSMB->hdr.Status.DosError.Error)) {
>-			return TRUE;	  
>+			return TRUE;
> 		} else {
> 			return FALSE; /* on valid oplock brk we get "request" */
> 		}
> 	}
>-	if(pSMB->hdr.WordCount != 8)
>+	if (pSMB->hdr.WordCount != 8)
> 		return FALSE;
> 
>-	cFYI(1,(" oplock type 0x%d level 0x%d",pSMB->LockType,pSMB->OplockLevel));
>-	if(!(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE))
>-		return FALSE;    
>+	cFYI(1, ("oplock type 0x%d level 0x%d",
>+		 pSMB->LockType, pSMB->OplockLevel));
>+	if (!(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE))
>+		return FALSE;
> 
> 	/* look up tcon based on tid & uid */
> 	read_lock(&GlobalSMBSeslock);
>@@ -580,36 +589,38 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
> 		tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
> 		if ((tcon->tid == buf->Tid) && (srv == tcon->ses->server)) {
> 			cifs_stats_inc(&tcon->num_oplock_brks);
>-			list_for_each(tmp1,&tcon->openFileList){
>-				netfile = list_entry(tmp1,struct cifsFileInfo,
>+			list_for_each(tmp1, &tcon->openFileList) {
>+				netfile = list_entry(tmp1, struct cifsFileInfo,
> 						     tlist);
>-				if(pSMB->Fid == netfile->netfid) {
>+				if (pSMB->Fid == netfile->netfid) {
> 					struct cifsInodeInfo *pCifsInode;
> 					read_unlock(&GlobalSMBSeslock);
>-					cFYI(1,("file id match, oplock break"));
>-					pCifsInode = 
>+					cFYI(1,
>+					    ("file id match, oplock break"));
>+					pCifsInode =
> 						CIFS_I(netfile->pInode);
> 					pCifsInode->clientCanCacheAll = FALSE;
>-					if(pSMB->OplockLevel == 0)
>+					if (pSMB->OplockLevel == 0)
> 						pCifsInode->clientCanCacheRead
> 							= FALSE;
> 					pCifsInode->oplockPending = TRUE;
> 					AllocOplockQEntry(netfile->pInode,
> 							  netfile->netfid,
> 							  tcon);
>-					cFYI(1,("about to wake up oplock thd"));
>-					if(oplockThread)
>+					cFYI(1,
>+					    ("about to wake up oplock thread"));
>+					if (oplockThread)
> 					    wake_up_process(oplockThread);
> 					return TRUE;
> 				}
> 			}
> 			read_unlock(&GlobalSMBSeslock);
>-			cFYI(1,("No matching file for oplock break"));
>+			cFYI(1, ("No matching file for oplock break"));
> 			return TRUE;
> 		}
> 	}
> 	read_unlock(&GlobalSMBSeslock);
>-	cFYI(1,("Can not process oplock break for non-existent connection"));
>+	cFYI(1, ("Can not process oplock break for non-existent connection"));
> 	return TRUE;
> }
> 
>@@ -666,13 +677,13 @@ dump_smb(struct smb_hdr *smb_buf, int smb_buf_length)
>    only legal in POSIX-like OS (if they are present in the string). Path
>    names are little endian 16 bit Unicode on the wire */
> int
>-cifs_convertUCSpath(char *target, const __le16 * source, int maxlen,
>-		    const struct nls_table * cp)
>+cifs_convertUCSpath(char *target, const __le16 *source, int maxlen,
>+		    const struct nls_table *cp)
> {
>-	int i,j,len;
>+	int i, j, len;
> 	__u16 src_char;
> 
>-	for(i = 0, j = 0; i < maxlen; i++) {
>+	for (i = 0, j = 0; i < maxlen; i++) {
> 		src_char = le16_to_cpu(source[i]);
> 		switch (src_char) {
> 			case 0:
>@@ -701,10 +712,10 @@ cifs_convertUCSpath(char *target, const __le16 * source, int maxlen,
> 			case UNI_LESSTHAN:
> 				target[j] = '<';
> 				break;
>-			default: 
>-				len = cp->uni2char(src_char, &target[j], 
>+			default:
>+				len = cp->uni2char(src_char, &target[j],
> 						NLS_MAX_CHARSET_SIZE);
>-				if(len > 0) {
>+				if (len > 0) {
> 					j += len;
> 					continue;
> 				} else {
>@@ -713,7 +724,7 @@ cifs_convertUCSpath(char *target, const __le16 * source, int maxlen,
> 		}
> 		j++;
> 		/* make sure we do not overrun callers allocated temp buffer */
>-		if(j >= (2 * NAME_MAX))
>+		if (j >= (2 * NAME_MAX))
> 			break;
> 	}
> cUCS_out:
>@@ -726,18 +737,18 @@ cUCS_out:
>    only legal in POSIX-like OS (if they are present in the string). Path
>    names are little endian 16 bit Unicode on the wire */
> int
>-cifsConvertToUCS(__le16 * target, const char *source, int maxlen, 
>-		 const struct nls_table * cp, int mapChars)
>+cifsConvertToUCS(__le16 *target, const char *source, int maxlen,
>+		 const struct nls_table *cp, int mapChars)
> {
>-	int i,j,charlen;
>+	int i, j, charlen;
> 	int len_remaining = maxlen;
> 	char src_char;
> 	__u16 temp;
> 
>-	if(!mapChars) 
>+	if (!mapChars)
> 		return cifs_strtoUCS(target, source, PATH_MAX, cp);
> 
>-	for(i = 0, j = 0; i < maxlen; j++) {
>+	for (i = 0, j = 0; i < maxlen; j++) {
> 		src_char = source[i];
> 		switch (src_char) {
> 			case 0:
>@@ -760,7 +771,7 @@ cifsConvertToUCS(__le16 * target, const char *source, int maxlen,
> 				break;
> 			case '|':
> 				target[j] = cpu_to_le16(UNI_PIPE);
>-				break;			
>+				break;
> 			/* BB We can not handle remapping slash until
> 			   all the calls to build_path_from_dentry
> 			   are modified, as they use slash as separator BB */
>@@ -772,7 +783,7 @@ cifsConvertToUCS(__le16 * target, const char *source, int maxlen,
> 					len_remaining, &temp);
> 				/* if no match, use question mark, which
> 				at least in some cases servers as wild card */
>-				if(charlen < 1) {
>+				if (charlen < 1) {
> 					target[j] = cpu_to_le16(0x003f);
> 					charlen = 1;
> 				} else
>@@ -781,7 +792,7 @@ cifsConvertToUCS(__le16 * target, const char *source, int maxlen,
> 				/* character may take more than one byte in the
> 				   the source string, but will take exactly two
> 				   bytes in the target string */
>-				i+= charlen;
>+				i += charlen;
> 				continue;
> 		}
> 		i++; /* move to next char in source string */
>diff --git a/fs/cifs/netmisc.c b/fs/cifs/netmisc.c
>index d5aff51..9c9c95d 100644
>--- a/fs/cifs/netmisc.c
>+++ b/fs/cifs/netmisc.c
>@@ -3,23 +3,22 @@
>  *
>  *   Copyright (c) International Business Machines  Corp., 2002
>  *   Author(s): Steve French (sfrench@us.ibm.com)
>- * 
>+ *
>  *   Error mapping routines from Samba libsmb/errormap.c
>  *   Copyright (C) Andrew Tridgell 2001
>  *
>- *
>  *   This program is free software;  you can redistribute it and/or modify
>  *   it under the terms of the GNU General Public License as published by
>- *   the Free Software Foundation; either version 2 of the License, or 
>+ *   the Free Software Foundation; either version 2 of the License, or
>  *   (at your option) any later version.
>- * 
>+ *
>  *   This program is distributed in the hope that it will be useful,
>  *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
>  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
>  *   the GNU General Public License for more details.
>  *
>  *   You should have received a copy of the GNU General Public License
>- *   along with this program;  if not, write to the Free Software 
>+ *   along with this program;  if not, write to the Free Software
>  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>  */
> 
>@@ -30,6 +29,7 @@
> #include <linux/fs.h>
> #include <asm/div64.h>
> #include <asm/byteorder.h>
>+#include <linux/inet.h>
> #include "cifsfs.h"
> #include "cifspdu.h"
> #include "cifsglob.h"
>@@ -64,22 +64,22 @@ static const struct smb_to_posix_error mapping_table_ERRDOS[] = {
> 	{ERRbadshare, -ETXTBSY},
> 	{ERRlock, -EACCES},
> 	{ERRunsup, -EINVAL},
>-	{ERRnosuchshare,-ENXIO},
>+	{ERRnosuchshare, -ENXIO},
> 	{ERRfilexists, -EEXIST},
> 	{ERRinvparm, -EINVAL},
> 	{ERRdiskfull, -ENOSPC},
> 	{ERRinvname, -ENOENT},
>-	{ERRinvlevel,-EOPNOTSUPP},
>+	{ERRinvlevel, -EOPNOTSUPP},
> 	{ERRdirnotempty, -ENOTEMPTY},
> 	{ERRnotlocked, -ENOLCK},
> 	{ERRcancelviolation, -ENOLCK},
> 	{ERRalreadyexists, -EEXIST},
> 	{ERRmoredata, -EOVERFLOW},
>-	{ERReasnotsupported,-EOPNOTSUPP},
>+	{ERReasnotsupported, -EOPNOTSUPP},
> 	{ErrQuota, -EDQUOT},
> 	{ErrNotALink, -ENOLINK},
>-	{ERRnetlogonNotStarted,-ENOPROTOOPT},
>-	{ErrTooManyLinks,-EMLINK},
>+	{ERRnetlogonNotStarted, -ENOPROTOOPT},
>+	{ErrTooManyLinks, -EMLINK},
> 	{0, 0}
> };
> 
>@@ -129,11 +129,27 @@ static const struct smb_to_posix_error mapping_table_ERRHRD[] = {
> /* Convert string containing dotted ip address to binary form */
> /* returns 0 if invalid address */
> 
>-/* BB add address family, change rc to status flag and return union or for ipv6 */
>-/*  will need parent to call something like inet_pton to convert ipv6 address  BB */
> int
>-cifs_inet_pton(int address_family, char *cp,void *dst)
>+cifs_inet_pton(int address_family, char *cp, void *dst)
> {
>+#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,19)
>+	int ret = 0;
>+
>+	/* calculate length by finding first slash or NULL */
>+	/* BB Should we convert '/' slash to '\' here since it seems already
>+	 * done before this */
>+	if ( address_family == AF_INET ) {
>+		ret = in4_pton(cp, -1 /* len */, dst , '\\', NULL);
>+	} else if ( address_family == AF_INET6 ) {
>+		ret = in6_pton(cp, -1 /* len */, dst , '\\', NULL);
>+	}
>+#ifdef CONFIG_CIFS_DEBUG2
>+	cFYI(1, ("address conversion returned %d for %s", ret, cp));
>+#endif
>+	if (ret > 0)
>+		ret = 1;
>+	return ret;
>+#else /* pre-2.6.20 */
> 	int value;
> 	int digit;
> 	int i;
>@@ -192,6 +208,7 @@ cifs_inet_pton(int address_family, char *cp,void *dst)
> 
> 	*((__be32 *)dst) = *((__be32 *) bytes) | htonl(value);
> 	return 1; /* success */
>+#endif
> }
> 
> /*****************************************************************************
>@@ -226,7 +243,7 @@ static const struct {
> 	ERRHRD, ERRgeneral, NT_STATUS_UNRECOGNIZED_MEDIA}, {
> 	ERRDOS, 27, NT_STATUS_NONEXISTENT_SECTOR},
> /*	{ This NT error code was 'sqashed'
>-	 from NT_STATUS_MORE_PROCESSING_REQUIRED to NT_STATUS_OK 
>+	 from NT_STATUS_MORE_PROCESSING_REQUIRED to NT_STATUS_OK
> 	 during the session setup } */
> 	{
> 	ERRDOS, ERRnomem, NT_STATUS_NO_MEMORY}, {
>@@ -241,7 +258,7 @@ static const struct {
> 	ERRDOS, 193, NT_STATUS_INVALID_FILE_FOR_SECTION}, {
> 	ERRDOS, ERRnoaccess, NT_STATUS_ALREADY_COMMITTED},
> /*	{ This NT error code was 'sqashed'
>-	 from NT_STATUS_ACCESS_DENIED to NT_STATUS_TRUSTED_RELATIONSHIP_FAILURE 
>+	 from NT_STATUS_ACCESS_DENIED to NT_STATUS_TRUSTED_RELATIONSHIP_FAILURE
> 	 during the session setup }   */
> 	{
> 	ERRDOS, ERRnoaccess, NT_STATUS_ACCESS_DENIED}, {
>@@ -311,7 +328,7 @@ static const struct {
> 	ERRHRD, ERRgeneral, NT_STATUS_INVALID_ACCOUNT_NAME}, {
> 	ERRHRD, ERRgeneral, NT_STATUS_USER_EXISTS},
> /*	{ This NT error code was 'sqashed'
>-	 from NT_STATUS_NO_SUCH_USER to NT_STATUS_LOGON_FAILURE 
>+	 from NT_STATUS_NO_SUCH_USER to NT_STATUS_LOGON_FAILURE
> 	 during the session setup } */
> 	{
> 	ERRDOS, ERRnoaccess, NT_STATUS_NO_SUCH_USER}, {
>@@ -321,7 +338,7 @@ static const struct {
> 	ERRHRD, ERRgeneral, NT_STATUS_MEMBER_NOT_IN_GROUP}, {
> 	ERRHRD, ERRgeneral, NT_STATUS_LAST_ADMIN},
> /*	{ This NT error code was 'sqashed'
>-	 from NT_STATUS_WRONG_PASSWORD to NT_STATUS_LOGON_FAILURE 
>+	 from NT_STATUS_WRONG_PASSWORD to NT_STATUS_LOGON_FAILURE
> 	 during the session setup } */
> 	{
> 	ERRSRV, ERRbadpw, NT_STATUS_WRONG_PASSWORD}, {
>@@ -373,8 +390,8 @@ static const struct {
> 	ERRHRD, ERRgeneral, NT_STATUS_FILE_INVALID}, {
> 	ERRHRD, ERRgeneral, NT_STATUS_ALLOTTED_SPACE_EXCEEDED},
> /*	{ This NT error code was 'sqashed'
>-	 from NT_STATUS_INSUFFICIENT_RESOURCES to NT_STATUS_INSUFF_SERVER_RESOURCES 
>-	 during the session setup } */
>+	 from NT_STATUS_INSUFFICIENT_RESOURCES to
>+	 NT_STATUS_INSUFF_SERVER_RESOURCES during the session setup } */
> 	{
> 	ERRDOS, ERRnomem, NT_STATUS_INSUFFICIENT_RESOURCES}, {
> 	ERRDOS, ERRbadpath, NT_STATUS_DFS_EXIT_PATH_FOUND}, {
>@@ -618,8 +635,8 @@ static const struct {
> 	ERRDOS, 19, NT_STATUS_TOO_LATE}, {
> 	ERRDOS, ERRnoaccess, NT_STATUS_NO_TRUST_LSA_SECRET},
> /*	{ This NT error code was 'sqashed'
>-	 from NT_STATUS_NO_TRUST_SAM_ACCOUNT to NT_STATUS_TRUSTED_RELATIONSHIP_FAILURE 
>-	 during the session setup } */
>+	 from NT_STATUS_NO_TRUST_SAM_ACCOUNT to
>+	 NT_STATUS_TRUSTED_RELATIONSHIP_FAILURE during the session setup } */
> 	{
> 	ERRDOS, ERRnoaccess, NT_STATUS_NO_TRUST_SAM_ACCOUNT}, {
> 	ERRDOS, ERRnoaccess, NT_STATUS_TRUSTED_DOMAIN_FAILURE}, {
>@@ -638,7 +655,7 @@ static const struct {
> 	ERRDOS, ERRnoaccess, NT_STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT}, {
> 	ERRDOS, ERRnoaccess, NT_STATUS_NOLOGON_SERVER_TRUST_ACCOUNT},
> /*	{ This NT error code was 'sqashed'
>-	 from NT_STATUS_DOMAIN_TRUST_INCONSISTENT to NT_STATUS_LOGON_FAILURE 
>+	 from NT_STATUS_DOMAIN_TRUST_INCONSISTENT to NT_STATUS_LOGON_FAILURE
> 	 during the session setup }  */
> 	{
> 	ERRDOS, ERRnoaccess, NT_STATUS_DOMAIN_TRUST_INCONSISTENT}, {
>@@ -769,7 +786,7 @@ cifs_print_status(__u32 status_code)
> 		if (((nt_errs[idx].nt_errcode) & 0xFFFFFF) ==
> 		    (status_code & 0xFFFFFF)) {
> 			printk(KERN_NOTICE "Status code returned 0x%08x %s\n",
>-				   status_code,nt_errs[idx].nt_errstr);
>+				   status_code, nt_errs[idx].nt_errstr);
> 		}
> 		idx++;
> 	}
>@@ -801,7 +818,7 @@ int
> map_smb_to_linux_error(struct smb_hdr *smb)
> {
> 	unsigned int i;
>-	int rc = -EIO;		/* if transport error smb error may not be set */
>+	int rc = -EIO;	/* if transport error smb error may not be set */
> 	__u8 smberrclass;
> 	__u16 smberrcode;
> 
>@@ -812,9 +829,10 @@ map_smb_to_linux_error(struct smb_hdr *smb)
> 		return 0;
> 
> 	if (smb->Flags2 & SMBFLG2_ERR_STATUS) {
>-		/* translate the newer STATUS codes to old style errors and then to POSIX errors */
>+		/* translate the newer STATUS codes to old style SMB errors
>+		 * and then to POSIX errors */
> 		__u32 err = le32_to_cpu(smb->Status.CifsError);
>-		if(cifsFYI & CIFS_RC)
>+		if (cifsFYI & CIFS_RC)
> 			cifs_print_status(err);
> 		ntstatus_to_dos(err, &smberrclass, &smberrcode);
> 	} else {
>@@ -825,38 +843,42 @@ map_smb_to_linux_error(struct smb_hdr *smb)
> 	/* old style errors */
> 
> 	/* DOS class smb error codes - map DOS */
>-	if (smberrclass == ERRDOS) {	/* one byte field no need to byte reverse */
>+	if (smberrclass == ERRDOS) {  /* 1 byte field no need to byte reverse */
> 		for (i = 0;
> 		     i <
> 		     sizeof (mapping_table_ERRDOS) /
> 		     sizeof (struct smb_to_posix_error); i++) {
> 			if (mapping_table_ERRDOS[i].smb_err == 0)
> 				break;
>-			else if (mapping_table_ERRDOS[i].smb_err == smberrcode) {
>+			else if (mapping_table_ERRDOS[i].smb_err ==
>+								smberrcode) {
> 				rc = mapping_table_ERRDOS[i].posix_code;
> 				break;
> 			}
>-			/* else try the next error mapping one to see if it will match */
>+			/* else try next error mapping one to see if match */
> 		}
>-	} else if (smberrclass == ERRSRV) {	/* server class of error codes */
>+	} else if (smberrclass == ERRSRV) {   /* server class of error codes */
> 		for (i = 0;
> 		     i <
> 		     sizeof (mapping_table_ERRSRV) /
> 		     sizeof (struct smb_to_posix_error); i++) {
> 			if (mapping_table_ERRSRV[i].smb_err == 0)
> 				break;
>-			else if (mapping_table_ERRSRV[i].smb_err == smberrcode) {
>+			else if (mapping_table_ERRSRV[i].smb_err ==
>+								smberrcode) {
> 				rc = mapping_table_ERRSRV[i].posix_code;
> 				break;
> 			}
>-			/* else try the next error mapping one to see if it will match */
>+			/* else try next error mapping to see if match */
> 		}
> 	}
> 	/* else ERRHRD class errors or junk  - return EIO */
> 
>-	cFYI(1, (" !!Mapping smb error code %d to POSIX err %d !!", smberrcode,rc));
>+	cFYI(1, (" !!Mapping smb error code %d to POSIX err %d !!",
>+		 smberrcode, rc));
> 
>-	/* generic corrective action e.g. reconnect SMB session on ERRbaduid could be added */
>+	/* generic corrective action e.g. reconnect SMB session on
>+	 * ERRbaduid could be added */
> 
> 	return rc;
> }
>@@ -888,11 +910,9 @@ smbCalcSize_LE(struct smb_hdr *ptr)
>      * into Unix UTC (based 1970-01-01, in seconds).
>      */
> 
>-
> static int total_days_of_prev_months[] =
> {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
> 
>-
> __le64 cnvrtDosCifsTm(__u16 date, __u16 time)
> {
> 	return cpu_to_le64(cifs_UnixTimeToNT(cnvrtDosUnixTm(date, time)));
>@@ -902,7 +922,7 @@ __le64 cnvrtDosCifsTm(__u16 date, __u16 time)
> struct timespec
> cifs_NTtimeToUnix(u64 ntutc)
> {
>-	struct timespec ts; 
>+	struct timespec ts;
> 	/* BB what about the timezone? BB */
> 
> 	/* Subtract the NTFS time offset, then convert to 1s intervals. */
>@@ -910,7 +930,7 @@ cifs_NTtimeToUnix(u64 ntutc)
> 
> 	t = ntutc - NTFS_TIME_OFFSET;
> 	ts.tv_nsec = do_div(t, 10000000) * 100;
>-	ts.tv_sec = t; 
>+	ts.tv_sec = t;
> 	return ts;
> }
> 
>@@ -922,6 +942,7 @@ cifs_UnixTimeToNT(struct timespec t)
> 	return (u64) t.tv_sec * 10000000 + t.tv_nsec/100 + NTFS_TIME_OFFSET;
> }
> 
>+
> struct timespec cnvrtDosUnixTm(__u16 date, __u16 time)
> {
> 	struct timespec ts;
>@@ -929,20 +950,20 @@ struct timespec cnvrtDosUnixTm(__u16 date, __u16 time)
> 	SMB_TIME * st = (SMB_TIME *)&time;
> 	SMB_DATE * sd = (SMB_DATE *)&date;
> 
>-	cFYI(1,("date %d time %d",date, time));
>+	cFYI(1, ("date %d time %d", date, time));
> 
> 	sec = 2 * st->TwoSeconds;
> 	min = st->Minutes;
>-	if((sec > 59) || (min > 59))
>-		cERROR(1,("illegal time min %d sec %d", min, sec));
>+	if ((sec > 59) || (min > 59))
>+		cERROR(1, ("illegal time min %d sec %d", min, sec));
> 	sec += (min * 60);
> 	sec += 60 * 60 * st->Hours;
>-	if(st->Hours > 24)
>-		cERROR(1,("illegal hours %d",st->Hours));
>+	if (st->Hours > 24)
>+		cERROR(1, ("illegal hours %d", st->Hours));
> 	days = sd->Day;
> 	month = sd->Month;
>-	if((days > 31) || (month > 12))
>-		cERROR(1,("illegal date, month %d day: %d", month, days));
>+	if ((days > 31) || (month > 12))
>+		cERROR(1, ("illegal date, month %d day: %d", month, days));
> 	month -= 1;
> 	days += total_days_of_prev_months[month];
> 	days += 3652; /* account for difference in days between 1980 and 1970 */
>@@ -953,22 +974,22 @@ struct timespec cnvrtDosUnixTm(__u16 date, __u16 time)
> 	for years/100 except for years/400, but since the maximum number for DOS
> 	 year is 2**7, the last year is 1980+127, which means we need only
> 	 consider 2 special case years, ie the years 2000 and 2100, and only
>-	 adjust for the lack of leap year for the year 2100, as 2000 was a 
>+	 adjust for the lack of leap year for the year 2100, as 2000 was a
> 	 leap year (divisable by 400) */
>-	if(year >= 120)  /* the year 2100 */
>+	if (year >= 120)  /* the year 2100 */
> 		days = days - 1;  /* do not count leap year for the year 2100 */
> 
> 	/* adjust for leap year where we are still before leap day */
>-	if(year != 120)
>+	if (year != 120)
> 		days -= ((year & 0x03) == 0) && (month < 2 ? 1 : 0);
>-	sec += 24 * 60 * 60 * days; 
>+	sec += 24 * 60 * 60 * days;
> 
> 	ts.tv_sec = sec;
> 
> 	/* cFYI(1,("sec after cnvrt dos to unix time %d",sec)); */
> 
> 	ts.tv_nsec = 0;
>-	return ts;	
>+	return ts;
> }
> #else
> /* Did not merge changeset 268f3be177ce93791da38facc34126b5038cd851
>diff --git a/fs/cifs/nterr.c b/fs/cifs/nterr.c
>index 4da50cd..819fd99 100644
>--- a/fs/cifs/nterr.c
>+++ b/fs/cifs/nterr.c
>@@ -1,19 +1,19 @@
>-/* 
>+/*
>  *  Unix SMB/Netbios implementation.
>  *  Version 1.9.
>  *  RPC Pipe client / server routines
>  *  Copyright (C) Luke Kenneth Casson Leighton 1997-2001.
>- *  
>+ *
>  *  This program is free software; you can redistribute it and/or modify
>  *  it under the terms of the GNU General Public License as published by
>  *  the Free Software Foundation; either version 2 of the License, or
>  *  (at your option) any later version.
>- *  
>+ *
>  *  This program is distributed in the hope that it will be useful,
>  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
>  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>  *  GNU General Public License for more details.
>- *  
>+ *
>  *  You should have received a copy of the GNU General Public License
>  *  along with this program; if not, write to the Free Software
>  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
>diff --git a/fs/cifs/nterr.h b/fs/cifs/nterr.h
>index d2fb06c..588abbb 100644
>--- a/fs/cifs/nterr.h
>+++ b/fs/cifs/nterr.h
>@@ -1,4 +1,4 @@
>-/* 
>+/*
>    Unix SMB/Netbios implementation.
>    Version 1.9.
>    NT error code constants
>@@ -6,17 +6,17 @@
>    Copyright (C) John H Terpstra              1996-2000
>    Copyright (C) Luke Kenneth Casson Leighton 1996-2000
>    Copyright (C) Paul Ashton                  1998-2000
>-   
>+
>    This program is free software; you can redistribute it and/or modify
>    it under the terms of the GNU General Public License as published by
>    the Free Software Foundation; either version 2 of the License, or
>    (at your option) any later version.
>-   
>+
>    This program is distributed in the hope that it will be useful,
>    but WITHOUT ANY WARRANTY; without even the implied warranty of
>    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>    GNU General Public License for more details.
>-   
>+
>    You should have received a copy of the GNU General Public License
>    along with this program; if not, write to the Free Software
>    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
>diff --git a/fs/cifs/ntlmssp.h b/fs/cifs/ntlmssp.h
>index d39b712..7170a9b 100644
>--- a/fs/cifs/ntlmssp.h
>+++ b/fs/cifs/ntlmssp.h
>@@ -1,7 +1,7 @@
> /*
>  *   fs/cifs/ntlmssp.h
>  *
>- *   Copyright (c) International Business Machines  Corp., 2002,2006
>+ *   Copyright (c) International Business Machines  Corp., 2002,2007
>  *   Author(s): Steve French (sfrench@us.ibm.com)
>  *
>  *   This library is free software; you can redistribute it and/or modify
>@@ -16,7 +16,7 @@
>  *
>  *   You should have received a copy of the GNU Lesser General Public License
>  *   along with this library; if not, write to the Free Software
>- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
>+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>  */
> 
> #define NTLMSSP_SIGNATURE "NTLMSSP"
>@@ -27,18 +27,18 @@
> #define UnknownMessage    cpu_to_le32(8)
> 
> /* Negotiate Flags */
>-#define NTLMSSP_NEGOTIATE_UNICODE       0x01	// Text strings are in unicode
>-#define NTLMSSP_NEGOTIATE_OEM           0x02	// Text strings are in OEM
>-#define NTLMSSP_REQUEST_TARGET          0x04	// Server return its auth realm
>-#define NTLMSSP_NEGOTIATE_SIGN        0x0010	// Request signature capability
>-#define NTLMSSP_NEGOTIATE_SEAL        0x0020	// Request confidentiality
>+#define NTLMSSP_NEGOTIATE_UNICODE       0x01 /* Text strings are in unicode */
>+#define NTLMSSP_NEGOTIATE_OEM           0x02 /* Text strings are in OEM */
>+#define NTLMSSP_REQUEST_TARGET          0x04 /* Server return its auth realm */
>+#define NTLMSSP_NEGOTIATE_SIGN        0x0010 /* Request signature capability */
>+#define NTLMSSP_NEGOTIATE_SEAL        0x0020 /*  Request confidentiality */
> #define NTLMSSP_NEGOTIATE_DGRAM       0x0040
>-#define NTLMSSP_NEGOTIATE_LM_KEY      0x0080 // Use LM session key for sign/seal
>-#define NTLMSSP_NEGOTIATE_NTLM        0x0200	// NTLM authentication
>+#define NTLMSSP_NEGOTIATE_LM_KEY      0x0080 /* Sign/seal use LM session key */
>+#define NTLMSSP_NEGOTIATE_NTLM        0x0200 /* NTLM authentication */
> #define NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED 0x1000
> #define NTLMSSP_NEGOTIATE_WORKSTATION_SUPPLIED 0x2000
>-#define NTLMSSP_NEGOTIATE_LOCAL_CALL  0x4000	// client/server on same machine
>-#define NTLMSSP_NEGOTIATE_ALWAYS_SIGN 0x8000	// Sign for all security levels
>+#define NTLMSSP_NEGOTIATE_LOCAL_CALL  0x4000 /* client/server on same machine */
>+#define NTLMSSP_NEGOTIATE_ALWAYS_SIGN 0x8000 /* Sign for all security levels */
> #define NTLMSSP_TARGET_TYPE_DOMAIN   0x10000
> #define NTLMSSP_TARGET_TYPE_SERVER   0x20000
> #define NTLMSSP_TARGET_TYPE_SHARE    0x40000
>diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
>index 5999729..38ca3fc 100644
>--- a/fs/cifs/readdir.c
>+++ b/fs/cifs/readdir.c
>@@ -2,7 +2,7 @@
>  *   fs/cifs/readdir.c
>  *
>  *   Directory search handling
>- * 
>+ *
>  *   Copyright (C) International Business Machines  Corp., 2004, 2007
>  *   Author(s): Steve French (sfrench@us.ibm.com)
>  *
>@@ -35,24 +35,23 @@
> #ifdef CONFIG_CIFS_DEBUG2
> static void dump_cifs_file_struct(struct file *file, char *label)
> {
>-	struct cifsFileInfo * cf;
>+	struct cifsFileInfo *cf;
> 
>-	if(file) {
>+	if (file) {
> 		cf = file->private_data;
>-		if(cf == NULL) {
>-			cFYI(1,("empty cifs private file data"));
>+		if (cf == NULL) {
>+			cFYI(1, ("empty cifs private file data"));
> 			return;
> 		}
>-		if(cf->invalidHandle) {
>-			cFYI(1,("invalid handle"));
>+		if (cf->invalidHandle) {
>+			cFYI(1, ("invalid handle"));
> 		}
>-		if(cf->srch_inf.endOfSearch) {
>-			cFYI(1,("end of search"));
>+		if (cf->srch_inf.endOfSearch) {
>+			cFYI(1, ("end of search"));
> 		}
>-		if(cf->srch_inf.emptyDir) {
>-			cFYI(1,("empty dir"));
>+		if (cf->srch_inf.emptyDir) {
>+			cFYI(1, ("empty dir"));
> 		}
>-		
> 	}
> }
> #endif /* DEBUG2 */
>@@ -68,48 +67,71 @@ static int construct_dentry(struct qstr *qstring, struct file *file,
> 	int rc = 0;
> 
> 	cFYI(1, ("For %s", qstring->name));
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
> 	pTcon = cifs_sb->tcon;
> 
> 	qstring->hash = full_name_hash(qstring->name, qstring->len);
> 	tmp_dentry = d_lookup(file->f_dentry, qstring);
> 	if (tmp_dentry) {
>-		cFYI(0, ("existing dentry with inode 0x%p", tmp_dentry->d_inode));
>+		cFYI(0, ("existing dentry with inode 0x%p",
>+			 tmp_dentry->d_inode));
> 		*ptmp_inode = tmp_dentry->d_inode;
> /* BB overwrite old name? i.e. tmp_dentry->d_name and tmp_dentry->d_name.len??*/
>-		if(*ptmp_inode == NULL) {
>+		if (*ptmp_inode == NULL) {
> 			*ptmp_inode = new_inode(file->f_dentry->d_sb);
>-			if(*ptmp_inode == NULL)
>+#else
>+	cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
>+	pTcon = cifs_sb->tcon;
>+
>+	qstring->hash = full_name_hash(qstring->name, qstring->len);
>+	tmp_dentry = d_lookup(file->f_path.dentry, qstring);
>+	if (tmp_dentry) {
>+		cFYI(0, ("existing dentry with inode 0x%p",
>+			 tmp_dentry->d_inode));
>+		*ptmp_inode = tmp_dentry->d_inode;
>+/* BB overwrite old name? i.e. tmp_dentry->d_name and tmp_dentry->d_name.len??*/
>+		if (*ptmp_inode == NULL) {
>+			*ptmp_inode = new_inode(file->f_path.dentry->d_sb);
>+#endif
>+			if (*ptmp_inode == NULL)
> 				return rc;
> 			rc = 1;
> 		}
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 19)
>-		if(file->f_path.dentry->d_sb->s_flags & MS_NOATIME)
>+		if (file->f_path.dentry->d_sb->s_flags & MS_NOATIME)
> #else
>-		if(file->f_dentry->d_sb->s_flags & MS_NOATIME)
>+		if (file->f_dentry->d_sb->s_flags & MS_NOATIME)
> #endif
> 			(*ptmp_inode)->i_flags |= S_NOATIME | S_NOCMTIME;
> 	} else {
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 		tmp_dentry = d_alloc(file->f_dentry, qstring);
>-		if(tmp_dentry == NULL) {
>-			cERROR(1,("Failed allocating dentry"));
>+#else
>+		tmp_dentry = d_alloc(file->f_path.dentry, qstring);
>+#endif
>+		if (tmp_dentry == NULL) {
>+			cERROR(1, ("Failed allocating dentry"));
> 			*ptmp_inode = NULL;
> 			return rc;
> 		}
>-
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 		*ptmp_inode = new_inode(file->f_dentry->d_sb);
>+#else
>+		*ptmp_inode = new_inode(file->f_path.dentry->d_sb);
>+#endif
> 		if (pTcon->nocase)
> 			tmp_dentry->d_op = &cifs_ci_dentry_ops;
> 		else
> 			tmp_dentry->d_op = &cifs_dentry_ops;
>-		if(*ptmp_inode == NULL)
>+		if (*ptmp_inode == NULL)
> 			return rc;
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 19)
>-		if(file->f_path.dentry->d_sb->s_flags & MS_NOATIME)
>+		if (file->f_path.dentry->d_sb->s_flags & MS_NOATIME)
> #else
>-		if(file->f_dentry->d_sb->s_flags & MS_NOATIME)
>+		if (file->f_dentry->d_sb->s_flags & MS_NOATIME)
> #endif
>-			(*ptmp_inode)->i_flags |= S_NOATIME | S_NOCMTIME;			
>+			(*ptmp_inode)->i_flags |= S_NOATIME | S_NOCMTIME;
> 		rc = 2;
> 	}
> 
>@@ -118,9 +140,9 @@ static int construct_dentry(struct qstr *qstring, struct file *file,
> 	return rc;
> }
> 
>-static void AdjustForTZ(struct cifsTconInfo * tcon, struct inode * inode)
>+static void AdjustForTZ(struct cifsTconInfo *tcon, struct inode *inode)
> {
>-	if((tcon) && (tcon->ses) && (tcon->ses->server)) {
>+	if ((tcon) && (tcon->ses) && (tcon->ses->server)) {
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
> 		inode->i_ctime.tv_sec += tcon->ses->server->timeAdj;
> 		inode->i_mtime.tv_sec += tcon->ses->server->timeAdj;
>@@ -136,7 +158,7 @@ static void AdjustForTZ(struct cifsTconInfo * tcon, struct inode * inode)
> 
> 
> static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
>-		char * buf, int *pobject_type, int isNewInode)
>+			  char *buf, int *pobject_type, int isNewInode)
> {
> 	loff_t local_size;
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
>@@ -145,6 +167,7 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
> 	time_t local_mtime;
> #endif
> 
>+
> 	struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
> 	struct cifs_sb_info *cifs_sb = CIFS_SB(tmp_inode->i_sb);
> 	__u32 attr;
>@@ -155,7 +178,7 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
> 	local_mtime = tmp_inode->i_mtime;
> 	local_size  = tmp_inode->i_size;
> 
>-	if(new_buf_type) {
>+	if (new_buf_type) {
> 		FILE_DIRECTORY_INFO *pfindData = (FILE_DIRECTORY_INFO *)buf;
> 
> 		attr = le32_to_cpu(pfindData->ExtFileAttributes);
>@@ -169,7 +192,7 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
> 		      cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
> 	} else { /* legacy, OS2 and DOS style */
> /*		struct timespec ts;*/
>-		FIND_FILE_STANDARD_INFO * pfindData = 
>+		FIND_FILE_STANDARD_INFO * pfindData =
> 			(FIND_FILE_STANDARD_INFO *)buf;
> 
> 		tmp_inode->i_mtime = cnvrtDosUnixTm(
>@@ -185,13 +208,6 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
> 		attr = le16_to_cpu(pfindData->Attributes);
> 		allocation_size = le32_to_cpu(pfindData->AllocationSize);
> 		end_of_file = le32_to_cpu(pfindData->DataSize);
>-		/* do not need to use current_fs_time helper function since
>-		 time not stored for this case so atime can not "go backwards"
>-		 by pulling newer older from disk when inode refrenshed */
>-		tmp_inode->i_atime = CURRENT_TIME;
>-		/* tmp_inode->i_mtime =  BB FIXME - add dos time handling
>-		tmp_inode->i_ctime = 0;   BB FIXME */
>-
> 	}
> 
> 	/* Linux can not store file creation time unfortunately so ignore it */
>@@ -201,7 +217,7 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
> 
> 	/* treat dos attribute of read-only as read-only mode bit e.g. 555? */
> 	/* 2767 perms - indicate mandatory locking */
>-		/* BB fill in uid and gid here? with help from winbind? 
>+		/* BB fill in uid and gid here? with help from winbind?
> 		   or retrieve from NTFS stream extended attribute */
> 	if (atomic_read(&cifsInfo->inUse) == 0) {
> 		tmp_inode->i_uid = cifs_sb->mnt_uid;
>@@ -218,11 +234,11 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
> 	if (attr & ATTR_DIRECTORY) {
> 		*pobject_type = DT_DIR;
> 		/* override default perms since we do not lock dirs */
>-		if(atomic_read(&cifsInfo->inUse) == 0) {
>+		if (atomic_read(&cifsInfo->inUse) == 0) {
> 			tmp_inode->i_mode = cifs_sb->mnt_dir_mode;
> 		}
> 		tmp_inode->i_mode |= S_IFDIR;
>-	} else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) && 
>+	} else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) &&
> 		   (attr & ATTR_SYSTEM)) {
> 		if (end_of_file == 0)  {
> 			*pobject_type = DT_FIFO;
>@@ -232,13 +248,13 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
> 			inode as needing revalidate and get the real type
> 			(blk vs chr vs. symlink) later ie in lookup */
> 			*pobject_type = DT_REG;
>-			tmp_inode->i_mode |= S_IFREG; 
>-			cifsInfo->time = 0;	
>+			tmp_inode->i_mode |= S_IFREG;
>+			cifsInfo->time = 0;
> 		}
> /* we no longer mark these because we could not follow them */
> /*        } else if (attr & ATTR_REPARSE) {
>-                *pobject_type = DT_LNK;
>-                tmp_inode->i_mode |= S_IFLNK; */
>+		*pobject_type = DT_LNK;
>+		tmp_inode->i_mode |= S_IFLNK; */
> 	} else {
> 		*pobject_type = DT_REG;
> 		tmp_inode->i_mode |= S_IFREG;
>@@ -246,7 +262,7 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
> 			tmp_inode->i_mode &= ~(S_IWUGO);
> 		else if ((tmp_inode->i_mode & S_IWUGO) == 0)
> 			/* the ATTR_READONLY flag may have been changed on   */
>-		   	/* server -- set any w bits allowed by mnt_file_mode */
>+			/* server -- set any w bits allowed by mnt_file_mode */
> 			tmp_inode->i_mode |= (S_IWUGO & cifs_sb->mnt_file_mode);
> 	} /* could add code here - to validate if device or weird share type? */
> 
>@@ -257,7 +273,7 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
> 
> 	spin_lock(&tmp_inode->i_lock);
> 	if (is_size_safe_to_change(cifsInfo, end_of_file)) {
>-		/* can not safely change the file size here if the 
>+		/* can not safely change the file size here if the
> 		client is writing to it due to potential races */
> 		i_size_write(tmp_inode, end_of_file);
> 
>@@ -270,30 +286,29 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
> 	if (allocation_size < end_of_file)
> 		cFYI(1, ("May be sparse file, allocation less than file size"));
> 	cFYI(1, ("File Size %ld and blocks %llu",
>-			(unsigned long)tmp_inode->i_size,
>-			(unsigned long long)tmp_inode->i_blocks));
>+		(unsigned long)tmp_inode->i_size,
>+		(unsigned long long)tmp_inode->i_blocks));
> 	if (S_ISREG(tmp_inode->i_mode)) {
> 		cFYI(1, ("File inode"));
> 		tmp_inode->i_op = &cifs_file_inode_ops;
>-		if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
>-			if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
>+		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
>+			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
> 				tmp_inode->i_fop = &cifs_file_direct_nobrl_ops;
> 			else
> 				tmp_inode->i_fop = &cifs_file_direct_ops;
>-		
>-		} else if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
>+		} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
> 			tmp_inode->i_fop = &cifs_file_nobrl_ops;
> 		else
> 			tmp_inode->i_fop = &cifs_file_ops;
> 
>-		if((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
>+		if ((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
> 		   (cifs_sb->tcon->ses->server->maxBuf <
> 			PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE))
> 			tmp_inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
> 		else
> 			tmp_inode->i_data.a_ops = &cifs_addr_ops;
> 
>-		if(isNewInode)
>+		if (isNewInode)
> 			return; /* No sense invalidating pages for new inode
> 				   since have not started caching readahead file
> 				   data yet */
>@@ -352,8 +367,8 @@ static void unix_fill_in_inode(struct inode *tmp_inode,
> 
> 	tmp_inode->i_mode = le64_to_cpu(pfindData->Permissions);
> 	/* since we set the inode type below we need to mask off type
>-           to avoid strange results if bits above were corrupt */
>-        tmp_inode->i_mode &= ~S_IFMT;
>+	   to avoid strange results if bits above were corrupt */
>+	tmp_inode->i_mode &= ~S_IFMT;
> 	if (type == UNIX_FILE) {
> 		*pobject_type = DT_REG;
> 		tmp_inode->i_mode |= S_IFREG;
>@@ -383,16 +398,22 @@ static void unix_fill_in_inode(struct inode *tmp_inode,
> 		/* safest to just call it a file */
> 		*pobject_type = DT_REG;
> 		tmp_inode->i_mode |= S_IFREG;
>-		cFYI(1,("unknown inode type %d",type)); 
>+		cFYI(1, ("unknown inode type %d", type));
> 	}
> 
>-	tmp_inode->i_uid = le64_to_cpu(pfindData->Uid);
>-	tmp_inode->i_gid = le64_to_cpu(pfindData->Gid);
>+	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
>+		tmp_inode->i_uid = cifs_sb->mnt_uid;
>+	else
>+		tmp_inode->i_uid = le64_to_cpu(pfindData->Uid);
>+	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
>+		tmp_inode->i_gid = cifs_sb->mnt_gid;
>+	else
>+		tmp_inode->i_gid = le64_to_cpu(pfindData->Gid);
> 	tmp_inode->i_nlink = le64_to_cpu(pfindData->Nlinks);
> 
> 	spin_lock(&tmp_inode->i_lock);
> 	if (is_size_safe_to_change(cifsInfo, end_of_file)) {
>-		/* can not safely change the file size here if the 
>+		/* can not safely change the file size here if the
> 		client is writing to it due to potential races */
> 		i_size_write(tmp_inode, end_of_file);
> 
>@@ -406,27 +427,27 @@ static void unix_fill_in_inode(struct inode *tmp_inode,
> 		cFYI(1, ("File inode"));
> 		tmp_inode->i_op = &cifs_file_inode_ops;
> 
>-		if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
>-			if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
>+		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
>+			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
> 				tmp_inode->i_fop = &cifs_file_direct_nobrl_ops;
> 			else
> 				tmp_inode->i_fop = &cifs_file_direct_ops;
>-		
>-		} else if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
>+		} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
> 			tmp_inode->i_fop = &cifs_file_nobrl_ops;
> 		else
> 			tmp_inode->i_fop = &cifs_file_ops;
> 
>-		if((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
>-		   (cifs_sb->tcon->ses->server->maxBuf < 
>+		if ((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
>+		   (cifs_sb->tcon->ses->server->maxBuf <
> 			PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE))
> 			tmp_inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
> 		else
> 			tmp_inode->i_data.a_ops = &cifs_addr_ops;
> 
>-		if(isNewInode)
>-			return; /* No sense invalidating pages for new inode since we
>-					   have not started caching readahead file data yet */
>+		if (isNewInode)
>+			return; /* No sense invalidating pages for new inode
>+				   since we have not started caching readahead
>+				   file data for it yet */
> 
> 		if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
> 			(local_size == tmp_inode->i_size)) {
>@@ -445,7 +466,7 @@ static void unix_fill_in_inode(struct inode *tmp_inode,
> 		tmp_inode->i_op = &cifs_symlink_inode_ops;
> /* tmp_inode->i_fop = *//* do not need to set to anything */
> 	} else {
>-		cFYI(1, ("Special inode")); 
>+		cFYI(1, ("Special inode"));
> 		init_special_inode(tmp_inode, tmp_inode->i_mode,
> 				   tmp_inode->i_rdev);
> 	}
>@@ -454,39 +475,45 @@ static void unix_fill_in_inode(struct inode *tmp_inode,
> static int initiate_cifs_search(const int xid, struct file *file)
> {
> 	int rc = 0;
>-	char * full_path;
>-	struct cifsFileInfo * cifsFile;
>+	char *full_path;
>+	struct cifsFileInfo *cifsFile;
> 	struct cifs_sb_info *cifs_sb;
> 	struct cifsTconInfo *pTcon;
> 
>-	if(file->private_data == NULL) {
>-		file->private_data = 
>-			kmalloc(sizeof(struct cifsFileInfo),GFP_KERNEL);
>+	if (file->private_data == NULL) {
>+		file->private_data =
>+			kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
> 	}
> 
>-	if(file->private_data == NULL) {
>+	if (file->private_data == NULL)
> 		return -ENOMEM;
>-	} else {
>-		memset(file->private_data,0,sizeof(struct cifsFileInfo));
>-	}
> 	cifsFile = file->private_data;
> 	cifsFile->invalidHandle = TRUE;
> 	cifsFile->srch_inf.endOfSearch = FALSE;
> 
>-	if(file->f_dentry == NULL)
>-		return -ENOENT;
>-
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
>-	if(cifs_sb == NULL)
>+	if (cifs_sb == NULL)
> 		return -EINVAL;
> 
> 	pTcon = cifs_sb->tcon;
>-	if(pTcon == NULL)
>+	if (pTcon == NULL)
> 		return -EINVAL;
> 
> 	full_path = build_path_from_dentry(file->f_dentry);
>+#else
>+	cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
>+	if (cifs_sb == NULL)
>+		return -EINVAL;
>+
>+	pTcon = cifs_sb->tcon;
>+	if (pTcon == NULL)
>+		return -EINVAL;
> 
>-	if(full_path == NULL) {
>+	full_path = build_path_from_dentry(file->f_path.dentry);
>+#endif
>+
>+	if (full_path == NULL) {
> 		return -ENOMEM;
> 	}
> 
>@@ -494,9 +521,11 @@ static int initiate_cifs_search(const int xid, struct file *file)
> 
> ffirst_retry:
> 	/* test for Unix extensions */
>-	if (pTcon->ses->capabilities & CAP_UNIX) {
>+	/* but now check for them on the share/mount not on the SMB session */
>+/*	if (pTcon->ses->capabilities & CAP_UNIX) { */
>+	if (pTcon->unix_ext) {
> 		cifsFile->srch_inf.info_level = SMB_FIND_FILE_UNIX;
>-	} else if ((pTcon->ses->capabilities & 
>+	} else if ((pTcon->ses->capabilities &
> 			(CAP_NT_SMBS | CAP_NT_FIND)) == 0) {
> 		cifsFile->srch_inf.info_level = SMB_FIND_FILE_INFO_STANDARD;
> 	} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
>@@ -505,13 +534,13 @@ ffirst_retry:
> 		cifsFile->srch_inf.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
> 	}
> 
>-	rc = CIFSFindFirst(xid, pTcon,full_path,cifs_sb->local_nls,
>+	rc = CIFSFindFirst(xid, pTcon, full_path, cifs_sb->local_nls,
> 		&cifsFile->netfid, &cifsFile->srch_inf,
>-		cifs_sb->mnt_cifs_flags & 
>+		cifs_sb->mnt_cifs_flags &
> 			CIFS_MOUNT_MAP_SPECIAL_CHR, CIFS_DIR_SEP(cifs_sb));
>-	if(rc == 0)
>+	if (rc == 0)
> 		cifsFile->invalidHandle = FALSE;
>-	if((rc == -EOPNOTSUPP) && 
>+	if ((rc == -EOPNOTSUPP) &&
> 		(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
> 		cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
> 		goto ffirst_retry;
>@@ -526,20 +555,20 @@ static int cifs_unicode_bytelen(char *str)
> 	int len;
> 	__le16 * ustr = (__le16 *)str;
> 
>-	for(len=0;len <= PATH_MAX;len++) {
>-		if(ustr[len] == 0)
>+	for (len = 0; len <= PATH_MAX; len++) {
>+		if (ustr[len] == 0)
> 			return len << 1;
> 	}
>-	cFYI(1,("Unicode string longer than PATH_MAX found"));
>+	cFYI(1, ("Unicode string longer than PATH_MAX found"));
> 	return len << 1;
> }
> 
> static char *nxt_dir_entry(char *old_entry, char *end_of_smb, int level)
> {
>-	char * new_entry;
>+	char *new_entry;
> 	FILE_DIRECTORY_INFO * pDirInfo = (FILE_DIRECTORY_INFO *)old_entry;
> 
>-	if(level == SMB_FIND_FILE_INFO_STANDARD) {
>+	if (level == SMB_FIND_FILE_INFO_STANDARD) {
> 		FIND_FILE_STANDARD_INFO * pfData;
> 		pfData = (FIND_FILE_STANDARD_INFO *)pDirInfo;
> 
>@@ -547,21 +576,21 @@ static char *nxt_dir_entry(char *old_entry, char *end_of_smb, int level)
> 				pfData->FileNameLength;
> 	} else
> 		new_entry = old_entry + le32_to_cpu(pDirInfo->NextEntryOffset);
>-	cFYI(1,("new entry %p old entry %p",new_entry,old_entry));
>+	cFYI(1, ("new entry %p old entry %p", new_entry, old_entry));
> 	/* validate that new_entry is not past end of SMB */
>-	if(new_entry >= end_of_smb) {
>+	if (new_entry >= end_of_smb) {
> 		cERROR(1,
> 		      ("search entry %p began after end of SMB %p old entry %p",
>-			new_entry, end_of_smb, old_entry)); 
>+			new_entry, end_of_smb, old_entry));
> 		return NULL;
>-	} else if(((level == SMB_FIND_FILE_INFO_STANDARD) &&
>-		   (new_entry + sizeof(FIND_FILE_STANDARD_INFO) > end_of_smb)) ||
>-		  ((level != SMB_FIND_FILE_INFO_STANDARD) &&
>+	} else if (((level == SMB_FIND_FILE_INFO_STANDARD) &&
>+		    (new_entry + sizeof(FIND_FILE_STANDARD_INFO) > end_of_smb))
>+		  || ((level != SMB_FIND_FILE_INFO_STANDARD) &&
> 		   (new_entry + sizeof(FILE_DIRECTORY_INFO) > end_of_smb)))  {
>-		cERROR(1,("search entry %p extends after end of SMB %p",
>+		cERROR(1, ("search entry %p extends after end of SMB %p",
> 			new_entry, end_of_smb));
> 		return NULL;
>-	} else 
>+	} else
> 		return new_entry;
> 
> }
>@@ -572,69 +601,70 @@ static char *nxt_dir_entry(char *old_entry, char *end_of_smb, int level)
> static int cifs_entry_is_dot(char *current_entry, struct cifsFileInfo *cfile)
> {
> 	int rc = 0;
>-	char * filename = NULL;
>-	int len = 0; 
>+	char *filename = NULL;
>+	int len = 0;
> 
>-	if(cfile->srch_inf.info_level == SMB_FIND_FILE_UNIX) {
>+	if (cfile->srch_inf.info_level == SMB_FIND_FILE_UNIX) {
> 		FILE_UNIX_INFO * pFindData = (FILE_UNIX_INFO *)current_entry;
> 		filename = &pFindData->FileName[0];
>-		if(cfile->srch_inf.unicode) {
>+		if (cfile->srch_inf.unicode) {
> 			len = cifs_unicode_bytelen(filename);
> 		} else {
> 			/* BB should we make this strnlen of PATH_MAX? */
> 			len = strnlen(filename, 5);
> 		}
>-	} else if(cfile->srch_inf.info_level == SMB_FIND_FILE_DIRECTORY_INFO) {
>-		FILE_DIRECTORY_INFO * pFindData = 
>+	} else if (cfile->srch_inf.info_level == SMB_FIND_FILE_DIRECTORY_INFO) {
>+		FILE_DIRECTORY_INFO * pFindData =
> 			(FILE_DIRECTORY_INFO *)current_entry;
> 		filename = &pFindData->FileName[0];
> 		len = le32_to_cpu(pFindData->FileNameLength);
>-	} else if(cfile->srch_inf.info_level == 
>+	} else if (cfile->srch_inf.info_level ==
> 			SMB_FIND_FILE_FULL_DIRECTORY_INFO) {
>-		FILE_FULL_DIRECTORY_INFO * pFindData = 
>+		FILE_FULL_DIRECTORY_INFO * pFindData =
> 			(FILE_FULL_DIRECTORY_INFO *)current_entry;
> 		filename = &pFindData->FileName[0];
> 		len = le32_to_cpu(pFindData->FileNameLength);
>-	} else if(cfile->srch_inf.info_level ==
>+	} else if (cfile->srch_inf.info_level ==
> 			SMB_FIND_FILE_ID_FULL_DIR_INFO) {
>-		SEARCH_ID_FULL_DIR_INFO * pFindData = 
>+		SEARCH_ID_FULL_DIR_INFO * pFindData =
> 			(SEARCH_ID_FULL_DIR_INFO *)current_entry;
> 		filename = &pFindData->FileName[0];
> 		len = le32_to_cpu(pFindData->FileNameLength);
>-	} else if(cfile->srch_inf.info_level == 
>+	} else if (cfile->srch_inf.info_level ==
> 			SMB_FIND_FILE_BOTH_DIRECTORY_INFO) {
>-		FILE_BOTH_DIRECTORY_INFO * pFindData = 
>+		FILE_BOTH_DIRECTORY_INFO * pFindData =
> 			(FILE_BOTH_DIRECTORY_INFO *)current_entry;
> 		filename = &pFindData->FileName[0];
> 		len = le32_to_cpu(pFindData->FileNameLength);
>-	} else if(cfile->srch_inf.info_level == SMB_FIND_FILE_INFO_STANDARD) {
>+	} else if (cfile->srch_inf.info_level == SMB_FIND_FILE_INFO_STANDARD) {
> 		FIND_FILE_STANDARD_INFO * pFindData =
> 			(FIND_FILE_STANDARD_INFO *)current_entry;
> 		filename = &pFindData->FileName[0];
>-		len = le32_to_cpu(pFindData->FileNameLength);
>+		len = pFindData->FileNameLength;
> 	} else {
>-		cFYI(1,("Unknown findfirst level %d",cfile->srch_inf.info_level));
>+		cFYI(1, ("Unknown findfirst level %d",
>+			 cfile->srch_inf.info_level));
> 	}
> 
>-	if(filename) {
>-		if(cfile->srch_inf.unicode) {
>+	if (filename) {
>+		if (cfile->srch_inf.unicode) {
> 			__le16 *ufilename = (__le16 *)filename;
>-			if(len == 2) {
>+			if (len == 2) {
> 				/* check for . */
>-				if(ufilename[0] == UNICODE_DOT)
>+				if (ufilename[0] == UNICODE_DOT)
> 					rc = 1;
>-			} else if(len == 4) {
>+			} else if (len == 4) {
> 				/* check for .. */
>-				if((ufilename[0] == UNICODE_DOT)
>-				   &&(ufilename[1] == UNICODE_DOT))
>+				if ((ufilename[0] == UNICODE_DOT)
>+				   && (ufilename[1] == UNICODE_DOT))
> 					rc = 2;
> 			}
> 		} else /* ASCII */ {
>-			if(len == 1) {
>-				if(filename[0] == '.') 
>+			if (len == 1) {
>+				if (filename[0] == '.')
> 					rc = 1;
>-			} else if(len == 2) {
>-				if((filename[0] == '.') && (filename[1] == '.')) 
>+			} else if (len == 2) {
>+				if ((filename[0] == '.') && (filename[1] == '.'))
> 					rc = 2;
> 			}
> 		}
>@@ -645,22 +675,16 @@ static int cifs_entry_is_dot(char *current_entry, struct cifsFileInfo *cfile)
> 
> /* Check if directory that we are searching has changed so we can decide
>    whether we can use the cached search results from the previous search */
>-static int is_dir_changed(struct file * file)
>+static int is_dir_changed(struct file *file)
> {
>-	struct inode * inode;
>-	struct cifsInodeInfo *cifsInfo;
>-
>-	if(file->f_dentry == NULL)
>-		return 0;
>-
>-	inode = file->f_dentry->d_inode;
>-
>-	if(inode == NULL)
>-		return 0;
>-
>-	cifsInfo = CIFS_I(inode);
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
>+	struct inode *inode = file->f_dentry->d_inode;
>+#else
>+	struct inode *inode = file->f_path.dentry->d_inode;
>+#endif
>+	struct cifsInodeInfo *cifsInfo = CIFS_I(inode);
> 
>-	if(cifsInfo->time == 0)
>+	if (cifsInfo->time == 0)
> 		return 1; /* directory was changed, perhaps due to unlink */
> 	else
> 		return 0;
>@@ -674,22 +698,22 @@ static int is_dir_changed(struct file * file)
> /* We start counting in the buffer with entry 2 and increment for every
>    entry (do not increment for . or .. entry) */
> static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
>-	struct file *file, char **ppCurrentEntry, int *num_to_ret) 
>+	struct file *file, char **ppCurrentEntry, int *num_to_ret)
> {
> 	int rc = 0;
> 	int pos_in_buf = 0;
> 	loff_t first_entry_in_buffer;
> 	loff_t index_to_find = file->f_pos;
>-	struct cifsFileInfo * cifsFile = file->private_data;
>+	struct cifsFileInfo *cifsFile = file->private_data;
> 	/* check if index in the buffer */
>-	
>-	if((cifsFile == NULL) || (ppCurrentEntry == NULL) || 
>+
>+	if ((cifsFile == NULL) || (ppCurrentEntry == NULL) ||
> 	   (num_to_ret == NULL))
> 		return -ENOENT;
>-	
>+
> 	*ppCurrentEntry = NULL;
>-	first_entry_in_buffer = 
>-		cifsFile->srch_inf.index_of_last_entry - 
>+	first_entry_in_buffer =
>+		cifsFile->srch_inf.index_of_last_entry -
> 			cifsFile->srch_inf.entries_in_buffer;
> 
> 	/* if first entry in buf is zero then is first buffer
>@@ -701,45 +725,46 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
> #ifdef CONFIG_CIFS_DEBUG2
> 	dump_cifs_file_struct(file, "In fce ");
> #endif
>-	if(((index_to_find < cifsFile->srch_inf.index_of_last_entry) && 
>-	     is_dir_changed(file)) || 
>+	if (((index_to_find < cifsFile->srch_inf.index_of_last_entry) &&
>+	     is_dir_changed(file)) ||
> 	   (index_to_find < first_entry_in_buffer)) {
> 		/* close and restart search */
>-		cFYI(1,("search backing up - close and restart search"));
>+		cFYI(1, ("search backing up - close and restart search"));
> 		cifsFile->invalidHandle = TRUE;
> 		CIFSFindClose(xid, pTcon, cifsFile->netfid);
> 		kfree(cifsFile->search_resume_name);
> 		cifsFile->search_resume_name = NULL;
>-		if(cifsFile->srch_inf.ntwrk_buf_start) {
>-			cFYI(1,("freeing SMB ff cache buf on search rewind"));
>-			if(cifsFile->srch_inf.smallBuf)
>+		if (cifsFile->srch_inf.ntwrk_buf_start) {
>+			cFYI(1, ("freeing SMB ff cache buf on search rewind"));
>+			if (cifsFile->srch_inf.smallBuf)
> 				cifs_small_buf_release(cifsFile->srch_inf.
> 						ntwrk_buf_start);
> 			else
> 				cifs_buf_release(cifsFile->srch_inf.
> 						ntwrk_buf_start);
> 		}
>-		rc = initiate_cifs_search(xid,file);
>-		if(rc) {
>-			cFYI(1,("error %d reinitiating a search on rewind",rc));
>+		rc = initiate_cifs_search(xid, file);
>+		if (rc) {
>+			cFYI(1, ("error %d reinitiating a search on rewind",
>+				 rc));
> 			return rc;
> 		}
> 	}
> 
>-	while((index_to_find >= cifsFile->srch_inf.index_of_last_entry) && 
>-	      (rc == 0) && (cifsFile->srch_inf.endOfSearch == FALSE)){
>-	 	cFYI(1,("calling findnext2"));
>-		rc = CIFSFindNext(xid,pTcon,cifsFile->netfid, 
>+	while ((index_to_find >= cifsFile->srch_inf.index_of_last_entry) &&
>+	      (rc == 0) && (cifsFile->srch_inf.endOfSearch == FALSE)) {
>+		cFYI(1, ("calling findnext2"));
>+		rc = CIFSFindNext(xid, pTcon, cifsFile->netfid,
> 				  &cifsFile->srch_inf);
>-		if(rc)
>+		if (rc)
> 			return -ENOENT;
> 	}
>-	if(index_to_find < cifsFile->srch_inf.index_of_last_entry) {
>+	if (index_to_find < cifsFile->srch_inf.index_of_last_entry) {
> 		/* we found the buffer that contains the entry */
> 		/* scan and find it */
> 		int i;
>-		char * current_entry;
>-		char * end_of_smb = cifsFile->srch_inf.ntwrk_buf_start + 
>+		char *current_entry;
>+		char *end_of_smb = cifsFile->srch_inf.ntwrk_buf_start +
> 			smbCalcSize((struct smb_hdr *)
> 				cifsFile->srch_inf.ntwrk_buf_start);
> 
>@@ -747,28 +772,28 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
> 		first_entry_in_buffer = cifsFile->srch_inf.index_of_last_entry
> 					- cifsFile->srch_inf.entries_in_buffer;
> 		pos_in_buf = index_to_find - first_entry_in_buffer;
>-		cFYI(1,("found entry - pos_in_buf %d",pos_in_buf));
>+		cFYI(1, ("found entry - pos_in_buf %d", pos_in_buf));
> 
>-		for(i=0;(i<(pos_in_buf)) && (current_entry != NULL);i++) {
>+		for (i=0; (i < (pos_in_buf)) && (current_entry != NULL); i++) {
> 			/* go entry by entry figuring out which is first */
>-			current_entry = nxt_dir_entry(current_entry,end_of_smb,
>+			current_entry = nxt_dir_entry(current_entry, end_of_smb,
> 						cifsFile->srch_inf.info_level);
> 		}
>-		if((current_entry == NULL) && (i < pos_in_buf)) {
>+		if ((current_entry == NULL) && (i < pos_in_buf)) {
> 			/* BB fixme - check if we should flag this error */
>-			cERROR(1,("reached end of buf searching for pos in buf"
>+			cERROR(1, ("reached end of buf searching for pos in buf"
> 			  " %d index to find %lld rc %d",
>-			  pos_in_buf,index_to_find,rc));
>+			  pos_in_buf, index_to_find, rc));
> 		}
> 		rc = 0;
> 		*ppCurrentEntry = current_entry;
> 	} else {
>-		cFYI(1,("index not in buffer - could not findnext into it"));
>+		cFYI(1, ("index not in buffer - could not findnext into it"));
> 		return 0;
> 	}
> 
>-	if(pos_in_buf >= cifsFile->srch_inf.entries_in_buffer) {
>-		cFYI(1,("can not return entries pos_in_buf beyond last entry"));
>+	if (pos_in_buf >= cifsFile->srch_inf.entries_in_buffer) {
>+		cFYI(1, ("can not return entries pos_in_buf beyond last"));
> 		*num_to_ret = 0;
> 	} else
> 		*num_to_ret = cifsFile->srch_inf.entries_in_buffer - pos_in_buf;
>@@ -779,81 +804,81 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
> /* inode num, inode type and filename returned */
> static int cifs_get_name_from_search_buf(struct qstr *pqst,
> 	char *current_entry, __u16 level, unsigned int unicode,
>-	struct cifs_sb_info * cifs_sb, int max_len, ino_t *pinum)
>+	struct cifs_sb_info *cifs_sb, int max_len, ino_t *pinum)
> {
> 	int rc = 0;
> 	unsigned int len = 0;
>-	char * filename;
>-	struct nls_table * nlt = cifs_sb->local_nls;
>+	char *filename;
>+	struct nls_table *nlt = cifs_sb->local_nls;
> 
> 	*pinum = 0;
> 
>-	if(level == SMB_FIND_FILE_UNIX) {
>-		FILE_UNIX_INFO * pFindData = (FILE_UNIX_INFO *)current_entry;
>+	if (level == SMB_FIND_FILE_UNIX) {
>+		FILE_UNIX_INFO *pFindData = (FILE_UNIX_INFO *)current_entry;
> 
> 		filename = &pFindData->FileName[0];
>-		if(unicode) {
>+		if (unicode) {
> 			len = cifs_unicode_bytelen(filename);
> 		} else {
> 			/* BB should we make this strnlen of PATH_MAX? */
> 			len = strnlen(filename, PATH_MAX);
> 		}
> 
>-		/* BB fixme - hash low and high 32 bits if not 64 bit arch BB fixme */
>-		if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
>+		/* BB fixme - hash low and high 32 bits if not 64 bit arch BB */
>+		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
> 			*pinum = pFindData->UniqueId;
>-	} else if(level == SMB_FIND_FILE_DIRECTORY_INFO) {
>-		FILE_DIRECTORY_INFO * pFindData = 
>+	} else if (level == SMB_FIND_FILE_DIRECTORY_INFO) {
>+		FILE_DIRECTORY_INFO *pFindData =
> 			(FILE_DIRECTORY_INFO *)current_entry;
> 		filename = &pFindData->FileName[0];
> 		len = le32_to_cpu(pFindData->FileNameLength);
>-	} else if(level == SMB_FIND_FILE_FULL_DIRECTORY_INFO) {
>-		FILE_FULL_DIRECTORY_INFO * pFindData = 
>+	} else if (level == SMB_FIND_FILE_FULL_DIRECTORY_INFO) {
>+		FILE_FULL_DIRECTORY_INFO *pFindData =
> 			(FILE_FULL_DIRECTORY_INFO *)current_entry;
> 		filename = &pFindData->FileName[0];
> 		len = le32_to_cpu(pFindData->FileNameLength);
>-	} else if(level == SMB_FIND_FILE_ID_FULL_DIR_INFO) {
>-		SEARCH_ID_FULL_DIR_INFO * pFindData = 
>+	} else if (level == SMB_FIND_FILE_ID_FULL_DIR_INFO) {
>+		SEARCH_ID_FULL_DIR_INFO *pFindData =
> 			(SEARCH_ID_FULL_DIR_INFO *)current_entry;
> 		filename = &pFindData->FileName[0];
> 		len = le32_to_cpu(pFindData->FileNameLength);
> 		*pinum = pFindData->UniqueId;
>-	} else if(level == SMB_FIND_FILE_BOTH_DIRECTORY_INFO) {
>-		FILE_BOTH_DIRECTORY_INFO * pFindData = 
>+	} else if (level == SMB_FIND_FILE_BOTH_DIRECTORY_INFO) {
>+		FILE_BOTH_DIRECTORY_INFO *pFindData =
> 			(FILE_BOTH_DIRECTORY_INFO *)current_entry;
> 		filename = &pFindData->FileName[0];
> 		len = le32_to_cpu(pFindData->FileNameLength);
>-	} else if(level == SMB_FIND_FILE_INFO_STANDARD) {
>+	} else if (level == SMB_FIND_FILE_INFO_STANDARD) {
> 		FIND_FILE_STANDARD_INFO * pFindData =
> 			(FIND_FILE_STANDARD_INFO *)current_entry;
> 		filename = &pFindData->FileName[0];
> 		/* one byte length, no name conversion */
> 		len = (unsigned int)pFindData->FileNameLength;
> 	} else {
>-		cFYI(1,("Unknown findfirst level %d",level));
>+		cFYI(1, ("Unknown findfirst level %d", level));
> 		return -EINVAL;
> 	}
> 
>-	if(len > max_len) {
>-		cERROR(1,("bad search response length %d past smb end", len));
>+	if (len > max_len) {
>+		cERROR(1, ("bad search response length %d past smb end", len));
> 		return -EINVAL;
> 	}
> 
>-	if(unicode) {
>+	if (unicode) {
> 		/* BB fixme - test with long names */
> 		/* Note converted filename can be longer than in unicode */
>-		if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
>+		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
> 			pqst->len = cifs_convertUCSpath((char *)pqst->name,
> 					(__le16 *)filename, len/2, nlt);
> 		else
> 			pqst->len = cifs_strfromUCS_le((char *)pqst->name,
>-					(__le16 *)filename,len/2,nlt);
>+					(__le16 *)filename, len/2, nlt);
> 	} else {
> 		pqst->name = filename;
> 		pqst->len = len;
> 	}
>-	pqst->hash = full_name_hash(pqst->name,pqst->len);
>-/*	cFYI(1,("filldir on %s",pqst->name));  */
>+	pqst->hash = full_name_hash(pqst->name, pqst->len);
>+/*	cFYI(1, ("filldir on %s",pqst->name));  */
> 	return rc;
> }
> 
>@@ -862,52 +887,54 @@ static int cifs_filldir(char *pfindEntry, struct file *file,
> {
> 	int rc = 0;
> 	struct qstr qstring;
>-	struct cifsFileInfo * pCifsF;
>+	struct cifsFileInfo *pCifsF;
> 	unsigned obj_type;
> 	ino_t  inum;
>-	struct cifs_sb_info * cifs_sb;
>+	struct cifs_sb_info *cifs_sb;
> 	struct inode *tmp_inode;
> 	struct dentry *tmp_dentry;
> 
> 	/* get filename and len into qstring */
> 	/* get dentry */
> 	/* decide whether to create and populate ionde */
>-	if((direntry == NULL) || (file == NULL))
>+	if ((direntry == NULL) || (file == NULL))
> 		return -EINVAL;
> 
> 	pCifsF = file->private_data;
>-	
>-	if((scratch_buf == NULL) || (pfindEntry == NULL) || (pCifsF == NULL))
>-		return -ENOENT;
> 
>-	if(file->f_dentry == NULL)
>+	if ((scratch_buf == NULL) || (pfindEntry == NULL) || (pCifsF == NULL))
> 		return -ENOENT;
> 
>-	rc = cifs_entry_is_dot(pfindEntry,pCifsF);
>+	rc = cifs_entry_is_dot(pfindEntry, pCifsF);
> 	/* skip . and .. since we added them first */
>-	if(rc != 0) 
>+	if (rc != 0)
> 		return 0;
> 
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
>+#else
>+	cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
>+#endif
> 
> 	qstring.name = scratch_buf;
>-	rc = cifs_get_name_from_search_buf(&qstring,pfindEntry,
>+	rc = cifs_get_name_from_search_buf(&qstring, pfindEntry,
> 			pCifsF->srch_inf.info_level,
>-			pCifsF->srch_inf.unicode,cifs_sb,
>+			pCifsF->srch_inf.unicode, cifs_sb,
> 			max_len,
> 			&inum /* returned */);
> 
>-	if(rc)
>+	if (rc)
> 		return rc;
> 
>-	rc = construct_dentry(&qstring,file,&tmp_inode, &tmp_dentry);
>-	if((tmp_inode == NULL) || (tmp_dentry == NULL))
>+	rc = construct_dentry(&qstring, file, &tmp_inode, &tmp_dentry);
>+	if ((tmp_inode == NULL) || (tmp_dentry == NULL))
> 		return -ENOMEM;
> 
>-	if(rc) {
>+	if (rc) {
> 		/* inode created, we need to hash it with right inode number */
>-		if(inum != 0) {
>-			/* BB fixme - hash the 2 32 quantities bits together if necessary BB */
>+		if (inum != 0) {
>+			/* BB fixme - hash the 2 32 quantities bits together if
>+			 *  necessary BB */
> 			tmp_inode->i_ino = inum;
> 		}
> 		insert_inode_hash(tmp_inode);
>@@ -916,27 +943,27 @@ static int cifs_filldir(char *pfindEntry, struct file *file,
> 	/* we pass in rc below, indicating whether it is a new inode,
> 	   so we can figure out whether to invalidate the inode cached
> 	   data if the file has changed */
>-	if(pCifsF->srch_inf.info_level == SMB_FIND_FILE_UNIX)
>+	if (pCifsF->srch_inf.info_level == SMB_FIND_FILE_UNIX)
> 		unix_fill_in_inode(tmp_inode,
> 				   (FILE_UNIX_INFO *)pfindEntry,
> 				   &obj_type, rc);
>-	else if(pCifsF->srch_inf.info_level == SMB_FIND_FILE_INFO_STANDARD)
>+	else if (pCifsF->srch_inf.info_level == SMB_FIND_FILE_INFO_STANDARD)
> 		fill_in_inode(tmp_inode, 0 /* old level 1 buffer type */,
> 				pfindEntry, &obj_type, rc);
> 	else
> 		fill_in_inode(tmp_inode, 1 /* NT */, pfindEntry, &obj_type, rc);
> 
>-	if(rc) /* new inode - needs to be tied to dentry */ {
>+	if (rc) /* new inode - needs to be tied to dentry */ {
> 		d_instantiate(tmp_dentry, tmp_inode);
>-		if(rc == 2)
>+		if (rc == 2)
> 			d_rehash(tmp_dentry);
> 	}
>-	
>-	
>-	rc = filldir(direntry,qstring.name,qstring.len,file->f_pos,
>-		     tmp_inode->i_ino,obj_type);
>-	if(rc) {
>-		cFYI(1,("filldir rc = %d",rc));
>+
>+
>+	rc = filldir(direntry, qstring.name, qstring.len, file->f_pos,
>+		     tmp_inode->i_ino, obj_type);
>+	if (rc) {
>+		cFYI(1, ("filldir rc = %d", rc));
> 		/* we can not return filldir errors to the caller
> 		since they are "normal" when the stat blocksize
> 		is too small - we return remapped error instead */
>@@ -953,57 +980,57 @@ static int cifs_save_resume_key(const char *current_entry,
> 	int rc = 0;
> 	unsigned int len = 0;
> 	__u16 level;
>-	char * filename;
>+	char *filename;
> 
>-	if((cifsFile == NULL) || (current_entry == NULL))
>+	if ((cifsFile == NULL) || (current_entry == NULL))
> 		return -EINVAL;
> 
> 	level = cifsFile->srch_inf.info_level;
> 
>-	if(level == SMB_FIND_FILE_UNIX) {
>+	if (level == SMB_FIND_FILE_UNIX) {
> 		FILE_UNIX_INFO * pFindData = (FILE_UNIX_INFO *)current_entry;
> 
> 		filename = &pFindData->FileName[0];
>-		if(cifsFile->srch_inf.unicode) {
>+		if (cifsFile->srch_inf.unicode) {
> 			len = cifs_unicode_bytelen(filename);
> 		} else {
> 			/* BB should we make this strnlen of PATH_MAX? */
> 			len = strnlen(filename, PATH_MAX);
> 		}
> 		cifsFile->srch_inf.resume_key = pFindData->ResumeKey;
>-	} else if(level == SMB_FIND_FILE_DIRECTORY_INFO) {
>-		FILE_DIRECTORY_INFO * pFindData = 
>+	} else if (level == SMB_FIND_FILE_DIRECTORY_INFO) {
>+		FILE_DIRECTORY_INFO *pFindData =
> 			(FILE_DIRECTORY_INFO *)current_entry;
> 		filename = &pFindData->FileName[0];
> 		len = le32_to_cpu(pFindData->FileNameLength);
> 		cifsFile->srch_inf.resume_key = pFindData->FileIndex;
>-	} else if(level == SMB_FIND_FILE_FULL_DIRECTORY_INFO) {
>-		FILE_FULL_DIRECTORY_INFO * pFindData = 
>+	} else if (level == SMB_FIND_FILE_FULL_DIRECTORY_INFO) {
>+		FILE_FULL_DIRECTORY_INFO *pFindData =
> 			(FILE_FULL_DIRECTORY_INFO *)current_entry;
> 		filename = &pFindData->FileName[0];
> 		len = le32_to_cpu(pFindData->FileNameLength);
> 		cifsFile->srch_inf.resume_key = pFindData->FileIndex;
>-	} else if(level == SMB_FIND_FILE_ID_FULL_DIR_INFO) {
>-		SEARCH_ID_FULL_DIR_INFO * pFindData = 
>+	} else if (level == SMB_FIND_FILE_ID_FULL_DIR_INFO) {
>+		SEARCH_ID_FULL_DIR_INFO *pFindData =
> 			(SEARCH_ID_FULL_DIR_INFO *)current_entry;
> 		filename = &pFindData->FileName[0];
> 		len = le32_to_cpu(pFindData->FileNameLength);
> 		cifsFile->srch_inf.resume_key = pFindData->FileIndex;
>-	} else if(level == SMB_FIND_FILE_BOTH_DIRECTORY_INFO) {
>-		FILE_BOTH_DIRECTORY_INFO * pFindData = 
>+	} else if (level == SMB_FIND_FILE_BOTH_DIRECTORY_INFO) {
>+		FILE_BOTH_DIRECTORY_INFO *pFindData =
> 			(FILE_BOTH_DIRECTORY_INFO *)current_entry;
> 		filename = &pFindData->FileName[0];
> 		len = le32_to_cpu(pFindData->FileNameLength);
> 		cifsFile->srch_inf.resume_key = pFindData->FileIndex;
>-	} else if(level == SMB_FIND_FILE_INFO_STANDARD) {
>-		FIND_FILE_STANDARD_INFO * pFindData =
>+	} else if (level == SMB_FIND_FILE_INFO_STANDARD) {
>+		FIND_FILE_STANDARD_INFO *pFindData =
> 			(FIND_FILE_STANDARD_INFO *)current_entry;
> 		filename = &pFindData->FileName[0];
> 		/* one byte length, no name conversion */
> 		len = (unsigned int)pFindData->FileNameLength;
> 		cifsFile->srch_inf.resume_key = pFindData->ResumeKey;
> 	} else {
>-		cFYI(1,("Unknown findfirst level %d",level));
>+		cFYI(1, ("Unknown findfirst level %d", level));
> 		return -EINVAL;
> 	}
> 	cifsFile->srch_inf.resume_name_len = len;
>@@ -1014,26 +1041,22 @@ static int cifs_save_resume_key(const char *current_entry,
> int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
> {
> 	int rc = 0;
>-	int xid,i;
>+	int xid, i;
> 	struct cifs_sb_info *cifs_sb;
> 	struct cifsTconInfo *pTcon;
> 	struct cifsFileInfo *cifsFile = NULL;
>-	char * current_entry;
>+	char *current_entry;
> 	int num_to_fill = 0;
>-	char * tmp_buf = NULL;
>-	char * end_of_smb;
>+	char *tmp_buf = NULL;
>+	char *end_of_smb;
> 	int max_len;
> 
> 	xid = GetXid();
> 
>-	if(file->f_dentry == NULL) {
>-		FreeXid(xid);
>-		return -EIO;
>-	}
>-
>+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
> 	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
> 	pTcon = cifs_sb->tcon;
>-	if(pTcon == NULL)
>+	if (pTcon == NULL)
> 		return -EINVAL;
> 
> 	switch ((int) file->f_pos) {
>@@ -1048,33 +1071,52 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
> 	case 1:
> 		if (filldir(direntry, "..", 2, file->f_pos,
> 		     file->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) {
>+#else
>+	cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
>+	pTcon = cifs_sb->tcon;
>+	if (pTcon == NULL)
>+		return -EINVAL;
>+
>+	switch ((int) file->f_pos) {
>+	case 0:
>+		if (filldir(direntry, ".", 1, file->f_pos,
>+		     file->f_path.dentry->d_inode->i_ino, DT_DIR) < 0) {
>+			cERROR(1, ("Filldir for current dir failed"));
>+			rc = -ENOMEM;
>+			break;
>+		}
>+		file->f_pos++;
>+	case 1:
>+		if (filldir(direntry, "..", 2, file->f_pos,
>+		     file->f_path.dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) {
>+#endif
> 			cERROR(1, ("Filldir for parent dir failed"));
> 			rc = -ENOMEM;
> 			break;
> 		}
> 		file->f_pos++;
> 	default:
>-		/* 1) If search is active, 
>-			is in current search buffer? 
>+		/* 1) If search is active,
>+			is in current search buffer?
> 			if it before then restart search
> 			if after then keep searching till find it */
> 
>-		if(file->private_data == NULL) {
>-			rc = initiate_cifs_search(xid,file);
>-			cFYI(1,("initiate cifs search rc %d",rc));
>-			if(rc) {
>+		if (file->private_data == NULL) {
>+			rc = initiate_cifs_search(xid, file);
>+			cFYI(1, ("initiate cifs search rc %d", rc));
>+			if (rc) {
> 				FreeXid(xid);
> 				return rc;
> 			}
> 		}
>-		if(file->private_data == NULL) {
>+		if (file->private_data == NULL) {
> 			rc = -EINVAL;
> 			FreeXid(xid);
> 			return rc;
> 		}
> 		cifsFile = file->private_data;
> 		if (cifsFile->srch_inf.endOfSearch) {
>-			if(cifsFile->srch_inf.emptyDir) {
>+			if (cifsFile->srch_inf.emptyDir) {
> 				cFYI(1, ("End of search, empty dir"));
> 				rc = 0;
> 				break;
>@@ -1082,23 +1124,23 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
> 		} /* else {
> 			cifsFile->invalidHandle = TRUE;
> 			CIFSFindClose(xid, pTcon, cifsFile->netfid);
>-		} 
>+		}
> 		kfree(cifsFile->search_resume_name);
> 		cifsFile->search_resume_name = NULL; */
> 
>-		rc = find_cifs_entry(xid,pTcon, file,
>-				&current_entry,&num_to_fill);
>-		if(rc) {
>-			cFYI(1,("fce error %d",rc)); 
>+		rc = find_cifs_entry(xid, pTcon, file,
>+				&current_entry, &num_to_fill);
>+		if (rc) {
>+			cFYI(1, ("fce error %d", rc));
> 			goto rddir2_exit;
> 		} else if (current_entry != NULL) {
>-			cFYI(1,("entry %lld found",file->f_pos));
>+			cFYI(1, ("entry %lld found", file->f_pos));
> 		} else {
>-			cFYI(1,("could not find entry"));
>+			cFYI(1, ("could not find entry"));
> 			goto rddir2_exit;
> 		}
>-		cFYI(1,("loop through %d times filling dir for net buf %p",
>-			num_to_fill,cifsFile->srch_inf.ntwrk_buf_start));
>+		cFYI(1, ("loop through %d times filling dir for net buf %p",
>+			num_to_fill, cifsFile->srch_inf.ntwrk_buf_start));
> 		max_len = smbCalcSize((struct smb_hdr *)
> 				cifsFile->srch_inf.ntwrk_buf_start);
> 		end_of_smb = cifsFile->srch_inf.ntwrk_buf_start + max_len;
>@@ -1108,10 +1150,10 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
> 		such multibyte target UTF-8 characters. cifs_unicode.c,
> 		which actually does the conversion, has the same limit */
> 		tmp_buf = kmalloc((2 * NAME_MAX) + 4, GFP_KERNEL);
>-		for(i=0;(i<num_to_fill) && (rc == 0);i++) {
>-			if(current_entry == NULL) {
>+		for (i = 0; (i < num_to_fill) && (rc == 0); i++) {
>+			if (current_entry == NULL) {
> 				/* evaluate whether this case is an error */
>-				cERROR(1,("past end of SMB num to fill %d i %d",
>+				cERROR(1, ("past SMB end,  num to fill %d i %d",
> 					  num_to_fill, i));
> 				break;
> 			}
>@@ -1119,20 +1161,20 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
> 			we want to check for that here? */
> 			rc = cifs_filldir(current_entry, file,
> 					filldir, direntry, tmp_buf, max_len);
>-			if(rc == -EOVERFLOW) {
>+			if (rc == -EOVERFLOW) {
> 				rc = 0;
> 				break;
> 			}
> 
> 			file->f_pos++;
>-			if(file->f_pos == 
>+			if (file->f_pos ==
> 				cifsFile->srch_inf.index_of_last_entry) {
>-				cFYI(1,("last entry in buf at pos %lld %s",
>-					file->f_pos,tmp_buf));
>-				cifs_save_resume_key(current_entry,cifsFile);
>+				cFYI(1, ("last entry in buf at pos %lld %s",
>+					file->f_pos, tmp_buf));
>+				cifs_save_resume_key(current_entry, cifsFile);
> 				break;
>-			} else 
>-				current_entry = 
>+			} else
>+				current_entry =
> 					nxt_dir_entry(current_entry, end_of_smb,
> 						cifsFile->srch_inf.info_level);
> 		}
>diff --git a/fs/cifs/rfc1002pdu.h b/fs/cifs/rfc1002pdu.h
>index aede606..8b69fcc 100644
>--- a/fs/cifs/rfc1002pdu.h
>+++ b/fs/cifs/rfc1002pdu.h
>@@ -18,7 +18,7 @@
>  *
>  *   You should have received a copy of the GNU Lesser General Public License
>  *   along with this library; if not, write to the Free Software
>- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
>+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>  */
> 
> /* NB: unlike smb/cifs packets, the RFC1002 structures are big endian */
>diff --git a/fs/cifs/sess.c b/fs/cifs/sess.c
>index 9a5c286..57ba714 100644
>--- a/fs/cifs/sess.c
>+++ b/fs/cifs/sess.c
>@@ -3,7 +3,7 @@
>  *
>  *   SMB/CIFS session setup handling routines
>  *
>- *   Copyright (c) International Business Machines  Corp., 2006
>+ *   Copyright (c) International Business Machines  Corp., 2006, 2007
>  *   Author(s): Steve French (sfrench@us.ibm.com)
>  *
>  *   This library is free software; you can redistribute it and/or modify
>@@ -32,7 +32,7 @@
> #include <linux/utsname.h>
> 
> extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
>-                         unsigned char *p24);
>+			 unsigned char *p24);
> 
> static __u32 cifs_ssetup_hdr(struct cifsSesInfo *ses, SESSION_SETUP_ANDX *pSMB)
> {
>@@ -46,13 +46,14 @@ static __u32 cifs_ssetup_hdr(struct cifsSesInfo *ses, SESSION_SETUP_ANDX *pSMB)
> 
> 	/* Now no need to set SMBFLG_CASELESS or obsolete CANONICAL PATH */
> 
>-	/* BB verify whether signing required on neg or just on auth frame 
>+	/* BB verify whether signing required on neg or just on auth frame
> 	   (and NTLM case) */
> 
> 	capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
> 			CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
> 
>-	if(ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
>+	if (ses->server->secMode &
>+	    (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
> 		pSMB->req.hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
> 
> 	if (ses->capabilities & CAP_UNICODE) {
>@@ -67,18 +68,17 @@ static __u32 cifs_ssetup_hdr(struct cifsSesInfo *ses, SESSION_SETUP_ANDX *pSMB)
> 		pSMB->req.hdr.Flags2 |= SMBFLG2_DFS;
> 		capabilities |= CAP_DFS;
> 	}
>-	if (ses->capabilities & CAP_UNIX) {
>+	if (ses->capabilities & CAP_UNIX)
> 		capabilities |= CAP_UNIX;
>-	}
> 
> 	/* BB check whether to init vcnum BB */
> 	return capabilities;
> }
> 
>-static void unicode_ssetup_strings(char ** pbcc_area, struct cifsSesInfo *ses,
>-			    const struct nls_table * nls_cp)
>+static void unicode_ssetup_strings(char **pbcc_area, struct cifsSesInfo *ses,
>+				   const struct nls_table *nls_cp)
> {
>-	char * bcc_ptr = *pbcc_area;
>+	char *bcc_ptr = *pbcc_area;
> 	int bytes_ret = 0;
> 
> 	/* BB FIXME add check that strings total less
>@@ -90,7 +90,7 @@ static void unicode_ssetup_strings(char ** pbcc_area, struct cifsSesInfo *ses,
> 		bcc_ptr++;
> 	} */
> 	/* copy user */
>-	if(ses->userName == NULL) {
>+	if (ses->userName == NULL) {
> 		/* null user mount */
> 		*bcc_ptr = 0;
> 		*(bcc_ptr+1) = 0;
>@@ -101,14 +101,14 @@ static void unicode_ssetup_strings(char ** pbcc_area, struct cifsSesInfo *ses,
> 	bcc_ptr += 2 * bytes_ret;
> 	bcc_ptr += 2; /* account for null termination */
> 	/* copy domain */
>-	if(ses->domainName == NULL) {
>+	if (ses->domainName == NULL) {
> 		/* Sending null domain better than using a bogus domain name (as
> 		we did briefly in 2.6.18) since server will use its default */
> 		*bcc_ptr = 0;
> 		*(bcc_ptr+1) = 0;
> 		bytes_ret = 0;
> 	} else
>-		bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, ses->domainName, 
>+		bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, ses->domainName,
> 					  256, nls_cp);
> 	bcc_ptr += 2 * bytes_ret;
> 	bcc_ptr += 2;  /* account for null terminator */
>@@ -118,7 +118,7 @@ static void unicode_ssetup_strings(char ** pbcc_area, struct cifsSesInfo *ses,
> 				  nls_cp);
> 	bcc_ptr += 2 * bytes_ret;
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 18)
>-	bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release,
>+	bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, init_utsname()->release,
> 				  32, nls_cp);
> #else
> 	bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, system_utsname.release,
>@@ -128,37 +128,37 @@ static void unicode_ssetup_strings(char ** pbcc_area, struct cifsSesInfo *ses,
> 	bcc_ptr += 2; /* trailing null */
> 
> 	bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
>-                                  32, nls_cp);
>+				  32, nls_cp);
> 	bcc_ptr += 2 * bytes_ret;
> 	bcc_ptr += 2; /* trailing null */
> 
> 	*pbcc_area = bcc_ptr;
> }
> 
>-static void ascii_ssetup_strings(char ** pbcc_area, struct cifsSesInfo *ses,
>-			  const struct nls_table * nls_cp)
>+static void ascii_ssetup_strings(char **pbcc_area, struct cifsSesInfo *ses,
>+				 const struct nls_table *nls_cp)
> {
>-	char * bcc_ptr = *pbcc_area;
>+	char *bcc_ptr = *pbcc_area;
> 
> 	/* copy user */
> 	/* BB what about null user mounts - check that we do this BB */
>-        /* copy user */
>-        if(ses->userName == NULL) {
>-                /* BB what about null user mounts - check that we do this BB */
>-        } else { /* 300 should be long enough for any conceivable user name */
>-                strncpy(bcc_ptr, ses->userName, 300);
>-        }
>+	/* copy user */
>+	if (ses->userName == NULL) {
>+		/* BB what about null user mounts - check that we do this BB */
>+	} else { /* 300 should be long enough for any conceivable user name */
>+		strncpy(bcc_ptr, ses->userName, 300);
>+	}
> 	/* BB improve check for overflow */
>-        bcc_ptr += strnlen(ses->userName, 300);
>+	bcc_ptr += strnlen(ses->userName, 300);
> 	*bcc_ptr = 0;
>-        bcc_ptr++; /* account for null termination */
>+	bcc_ptr++; /* account for null termination */
>+
>+	/* copy domain */
> 
>-        /* copy domain */
>-	
>-        if(ses->domainName != NULL) {
>-                strncpy(bcc_ptr, ses->domainName, 256); 
>+	if (ses->domainName != NULL) {
>+		strncpy(bcc_ptr, ses->domainName, 256);
> 		bcc_ptr += strnlen(ses->domainName, 256);
>-	} /* else we will send a null domain name 
>+	} /* else we will send a null domain name
> 	     so the server will default to its own domain */
> 	*bcc_ptr = 0;
> 	bcc_ptr++;
>@@ -168,29 +168,29 @@ static void ascii_ssetup_strings(char ** pbcc_area, struct cifsSesInfo *ses,
> 	strcpy(bcc_ptr, "Linux version ");
> 	bcc_ptr += strlen("Linux version ");
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 18)
>-	strcpy(bcc_ptr, utsname()->release);
>-	bcc_ptr += strlen(utsname()->release) + 1;
>+	strcpy(bcc_ptr, init_utsname()->release);
>+	bcc_ptr += strlen(init_utsname()->release) + 1;
> #else
> 	strcpy(bcc_ptr, system_utsname.release);
> 	bcc_ptr += strlen(system_utsname.release) + 1;
> #endif
>-
> 	strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
> 	bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
> 
>-        *pbcc_area = bcc_ptr;
>+	*pbcc_area = bcc_ptr;
> }
> 
>-static int decode_unicode_ssetup(char ** pbcc_area, int bleft, struct cifsSesInfo *ses,
>-                            const struct nls_table * nls_cp)
>+static int decode_unicode_ssetup(char **pbcc_area, int bleft,
>+				 struct cifsSesInfo *ses,
>+				 const struct nls_table *nls_cp)
> {
> 	int rc = 0;
> 	int words_left, len;
>-	char * data = *pbcc_area;
>+	char *data = *pbcc_area;
> 
> 
> 
>-	cFYI(1,("bleft %d",bleft));
>+	cFYI(1, ("bleft %d", bleft));
> 
> 
> 	/* SMB header is unaligned, so cifs servers word align start of
>@@ -200,7 +200,7 @@ static int decode_unicode_ssetup(char ** pbcc_area, int bleft, struct cifsSesInf
> 		    their final Unicode string - in which case we
> 		    now will not attempt to decode the byte of junk
> 		    which follows it */
>-		    
>+
> 	words_left = bleft / 2;
> 
> 	/* save off server operating system */
>@@ -209,84 +209,79 @@ static int decode_unicode_ssetup(char ** pbcc_area, int bleft, struct cifsSesInf
> /* We look for obvious messed up bcc or strings in response so we do not go off
>    the end since (at least) WIN2K and Windows XP have a major bug in not null
>    terminating last Unicode string in response  */
>-	if(len >= words_left)
>+	if (len >= words_left)
> 		return rc;
> 
>-	if(ses->serverOS)
>-		kfree(ses->serverOS);
>+	kfree(ses->serverOS);
> 	/* UTF-8 string will not grow more than four times as big as UCS-16 */
> 	ses->serverOS = kzalloc(4 * len, GFP_KERNEL);
>-	if(ses->serverOS != NULL) {
>-		cifs_strfromUCS_le(ses->serverOS, (__le16 *)data, len,
>-				   nls_cp);
>-	}
>+	if (ses->serverOS != NULL)
>+		cifs_strfromUCS_le(ses->serverOS, (__le16 *)data, len, nls_cp);
> 	data += 2 * (len + 1);
> 	words_left -= len + 1;
> 
> 	/* save off server network operating system */
> 	len = UniStrnlen((wchar_t *) data, words_left);
> 
>-	if(len >= words_left)
>+	if (len >= words_left)
> 		return rc;
> 
>-	if(ses->serverNOS)
>-		kfree(ses->serverNOS);
>+	kfree(ses->serverNOS);
> 	ses->serverNOS = kzalloc(4 * len, GFP_KERNEL); /* BB this is wrong length FIXME BB */
>-	if(ses->serverNOS != NULL) {
>+	if (ses->serverNOS != NULL) {
> 		cifs_strfromUCS_le(ses->serverNOS, (__le16 *)data, len,
> 				   nls_cp);
>-		if(strncmp(ses->serverNOS, "NT LAN Manager 4",16) == 0) {
>-			cFYI(1,("NT4 server"));
>+		if (strncmp(ses->serverNOS, "NT LAN Manager 4", 16) == 0) {
>+			cFYI(1, ("NT4 server"));
> 			ses->flags |= CIFS_SES_NT4;
> 		}
> 	}
> 	data += 2 * (len + 1);
> 	words_left -= len + 1;
> 
>-        /* save off server domain */
>-        len = UniStrnlen((wchar_t *) data, words_left);
>-
>-        if(len > words_left)
>-                return rc;
>-
>-        if(ses->serverDomain)
>-                kfree(ses->serverDomain);
>-        ses->serverDomain = kzalloc(2 * (len + 1), GFP_KERNEL); /* BB FIXME wrong length */
>-        if(ses->serverDomain != NULL) {
>-                cifs_strfromUCS_le(ses->serverDomain, (__le16 *)data, len,
>-                                   nls_cp);
>-                ses->serverDomain[2*len] = 0;
>-                ses->serverDomain[(2*len) + 1] = 0;
>-        }
>-        data += 2 * (len + 1);
>-        words_left -= len + 1;
>-	
>-	cFYI(1,("words left: %d",words_left));
>+	/* save off server domain */
>+	len = UniStrnlen((wchar_t *) data, words_left);
>+
>+	if (len > words_left)
>+		return rc;
>+
>+	kfree(ses->serverDomain);
>+	ses->serverDomain = kzalloc(2 * (len + 1), GFP_KERNEL); /* BB FIXME wrong length */
>+	if (ses->serverDomain != NULL) {
>+		cifs_strfromUCS_le(ses->serverDomain, (__le16 *)data, len,
>+				   nls_cp);
>+		ses->serverDomain[2*len] = 0;
>+		ses->serverDomain[(2*len) + 1] = 0;
>+	}
>+	data += 2 * (len + 1);
>+	words_left -= len + 1;
>+
>+	cFYI(1, ("words left: %d", words_left));
> 
> 	return rc;
> }
> 
>-static int decode_ascii_ssetup(char ** pbcc_area, int bleft, struct cifsSesInfo *ses,
>-                            const struct nls_table * nls_cp)
>+static int decode_ascii_ssetup(char **pbcc_area, int bleft,
>+			       struct cifsSesInfo *ses,
>+			       const struct nls_table *nls_cp)
> {
> 	int rc = 0;
> 	int len;
>-	char * bcc_ptr = *pbcc_area;
>+	char *bcc_ptr = *pbcc_area;
>+
>+	cFYI(1, ("decode sessetup ascii. bleft %d", bleft));
> 
>-	cFYI(1,("decode sessetup ascii. bleft %d", bleft));
>-	
> 	len = strnlen(bcc_ptr, bleft);
>-	if(len >= bleft)
>+	if (len >= bleft)
> 		return rc;
>-	
>-	if(ses->serverOS)
>-		kfree(ses->serverOS);
>+
>+	kfree(ses->serverOS);
> 
> 	ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
>-	if(ses->serverOS)
>+	if (ses->serverOS)
> 		strncpy(ses->serverOS, bcc_ptr, len);
>-	if(strncmp(ses->serverOS, "OS/2",4) == 0) {
>-			cFYI(1,("OS/2 server"));
>+	if (strncmp(ses->serverOS, "OS/2", 4) == 0) {
>+			cFYI(1, ("OS/2 server"));
> 			ses->flags |= CIFS_SES_OS2;
> 	}
> 
>@@ -294,34 +289,33 @@ static int decode_ascii_ssetup(char ** pbcc_area, int bleft, struct cifsSesInfo
> 	bleft -= len + 1;
> 
> 	len = strnlen(bcc_ptr, bleft);
>-	if(len >= bleft)
>+	if (len >= bleft)
> 		return rc;
> 
>-	if(ses->serverNOS)
>-		kfree(ses->serverNOS);
>+	kfree(ses->serverNOS);
> 
> 	ses->serverNOS = kzalloc(len + 1, GFP_KERNEL);
>-	if(ses->serverNOS)
>+	if (ses->serverNOS)
> 		strncpy(ses->serverNOS, bcc_ptr, len);
> 
> 	bcc_ptr += len + 1;
> 	bleft -= len + 1;
> 
>-        len = strnlen(bcc_ptr, bleft);
>-        if(len > bleft)
>-                return rc;
>+	len = strnlen(bcc_ptr, bleft);
>+	if (len > bleft)
>+		return rc;
> 
> 	/* No domain field in LANMAN case. Domain is
> 	   returned by old servers in the SMB negprot response */
> 	/* BB For newer servers which do not support Unicode,
> 	   but thus do return domain here we could add parsing
> 	   for it later, but it is not very important */
>-	cFYI(1,("ascii: bytes left %d",bleft));
>+	cFYI(1, ("ascii: bytes left %d", bleft));
> 
> 	return rc;
> }
> 
>-int 
>+int
> CIFS_SessSetup(unsigned int xid, struct cifsSesInfo *ses, int first_time,
> 		const struct nls_table *nls_cp)
> {
>@@ -339,13 +333,13 @@ CIFS_SessSetup(unsigned int xid, struct cifsSesInfo *ses, int first_time,
> 	__u16 action;
> 	int bytes_remaining;
> 
>-	if(ses == NULL)
>+	if (ses == NULL)
> 		return -EINVAL;
> 
> 	type = ses->server->secType;
> 
>-	cFYI(1,("sess setup type %d",type));
>-	if(type == LANMAN) {
>+	cFYI(1, ("sess setup type %d", type));
>+	if (type == LANMAN) {
> #ifndef CONFIG_CIFS_WEAK_PW_HASH
> 		/* LANMAN and plaintext are less secure and off by default.
> 		So we make this explicitly be turned on in kconfig (in the
>@@ -355,15 +349,15 @@ CIFS_SessSetup(unsigned int xid, struct cifsSesInfo *ses, int first_time,
> 		return -EOPNOTSUPP;
> #endif
> 		wct = 10; /* lanman 2 style sessionsetup */
>-	} else if((type == NTLM) || (type == NTLMv2)) { 
>+	} else if ((type == NTLM) || (type == NTLMv2)) {
> 		/* For NTLMv2 failures eventually may need to retry NTLM */
> 		wct = 13; /* old style NTLM sessionsetup */
>-	} else /* same size for negotiate or auth, NTLMSSP or extended security */
>+	} else /* same size: negotiate or auth, NTLMSSP or extended security */
> 		wct = 12;
> 
> 	rc = small_smb_init_no_tc(SMB_COM_SESSION_SETUP_ANDX, wct, ses,
> 			    (void **)&smb_buf);
>-	if(rc)
>+	if (rc)
> 		return rc;
> 
> 	pSMB = (SESSION_SETUP_ANDX *)smb_buf;
>@@ -375,27 +369,31 @@ CIFS_SessSetup(unsigned int xid, struct cifsSesInfo *ses, int first_time,
> 	second part which will include the strings
> 	and rest of bcc area, in order to avoid having
> 	to do a large buffer 17K allocation */
>-        iov[0].iov_base = (char *)pSMB;
>-        iov[0].iov_len = smb_buf->smb_buf_length + 4;
>+	iov[0].iov_base = (char *)pSMB;
>+	iov[0].iov_len = smb_buf->smb_buf_length + 4;
> 
> 	/* 2000 big enough to fit max user, domain, NOS name etc. */
> 	str_area = kmalloc(2000, GFP_KERNEL);
>+	if (str_area == NULL) {
>+		cifs_small_buf_release(smb_buf);
>+		return -ENOMEM;
>+	}
> 	bcc_ptr = str_area;
> 
> 	ses->flags &= ~CIFS_SES_LANMAN;
> 
>-	if(type == LANMAN) {
>+	if (type == LANMAN) {
> #ifdef CONFIG_CIFS_WEAK_PW_HASH
> 		char lnm_session_key[CIFS_SESS_KEY_SIZE];
> 
> 		/* no capabilities flags in old lanman negotiation */
> 
>-		pSMB->old_req.PasswordLength = CIFS_SESS_KEY_SIZE; 
>+		pSMB->old_req.PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
> 		/* BB calculate hash with password */
> 		/* and copy into bcc */
> 
> 		calc_lanman_hash(ses, lnm_session_key);
>-		ses->flags |= CIFS_SES_LANMAN; 
>+		ses->flags |= CIFS_SES_LANMAN;
> /* #ifdef CONFIG_CIFS_DEBUG2
> 		cifs_dump_mem("cryptkey: ",ses->server->cryptKey,
> 			CIFS_SESS_KEY_SIZE);
>@@ -408,10 +406,10 @@ CIFS_SessSetup(unsigned int xid, struct cifsSesInfo *ses, int first_time,
> 		changed to do higher than lanman dialect and
> 		we reconnected would we ever calc signing_key? */
> 
>-		cFYI(1,("Negotiating LANMAN setting up strings"));
>+		cFYI(1, ("Negotiating LANMAN setting up strings"));
> 		/* Unicode not allowed for LANMAN dialects */
> 		ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
>-#endif    
>+#endif
> 	} else if (type == NTLM) {
> 		char ntlm_session_key[CIFS_SESS_KEY_SIZE];
> 
>@@ -420,38 +418,38 @@ CIFS_SessSetup(unsigned int xid, struct cifsSesInfo *ses, int first_time,
> 			cpu_to_le16(CIFS_SESS_KEY_SIZE);
> 		pSMB->req_no_secext.CaseSensitivePasswordLength =
> 			cpu_to_le16(CIFS_SESS_KEY_SIZE);
>-	
>+
> 		/* calculate session key */
> 		SMBNTencrypt(ses->password, ses->server->cryptKey,
> 			     ntlm_session_key);
> 
>-		if(first_time) /* should this be moved into common code 
>+		if (first_time) /* should this be moved into common code
> 				  with similar ntlmv2 path? */
>-			cifs_calculate_mac_key(ses->server->mac_signing_key,
>+			cifs_calculate_mac_key(&ses->server->mac_signing_key,
> 				ntlm_session_key, ses->password);
> 		/* copy session key */
> 
>-		memcpy(bcc_ptr, (char *)ntlm_session_key,CIFS_SESS_KEY_SIZE);
>+		memcpy(bcc_ptr, (char *)ntlm_session_key, CIFS_SESS_KEY_SIZE);
> 		bcc_ptr += CIFS_SESS_KEY_SIZE;
>-		memcpy(bcc_ptr, (char *)ntlm_session_key,CIFS_SESS_KEY_SIZE);
>+		memcpy(bcc_ptr, (char *)ntlm_session_key, CIFS_SESS_KEY_SIZE);
> 		bcc_ptr += CIFS_SESS_KEY_SIZE;
>-		if(ses->capabilities & CAP_UNICODE) {
>+		if (ses->capabilities & CAP_UNICODE) {
> 			/* unicode strings must be word aligned */
> 			if (iov[0].iov_len % 2) {
> 				*bcc_ptr = 0;
>-				bcc_ptr++;		
>-			}	
>+				bcc_ptr++;
>+			}
> 			unicode_ssetup_strings(&bcc_ptr, ses, nls_cp);
> 		} else
> 			ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
> 	} else if (type == NTLMv2) {
>-		char * v2_sess_key = 
>+		char *v2_sess_key =
> 			kmalloc(sizeof(struct ntlmv2_resp), GFP_KERNEL);
> 
> 		/* BB FIXME change all users of v2_sess_key to
> 		   struct ntlmv2_resp */
> 
>-		if(v2_sess_key == NULL) {
>+		if (v2_sess_key == NULL) {
> 			cifs_small_buf_release(smb_buf);
> 			return -ENOMEM;
> 		}
>@@ -467,8 +465,8 @@ CIFS_SessSetup(unsigned int xid, struct cifsSesInfo *ses, int first_time,
> 
> 		/* calculate session key */
> 		setup_ntlmv2_rsp(ses, v2_sess_key, nls_cp);
>-		if(first_time) /* should this be moved into common code
>-			          with similar ntlmv2 path? */
>+		if (first_time) /* should this be moved into common code
>+				   with similar ntlmv2 path? */
> 		/*   cifs_calculate_ntlmv2_mac_key(ses->server->mac_signing_key,
> 				response BB FIXME, v2_sess_key); */
> 
>@@ -476,13 +474,15 @@ CIFS_SessSetup(unsigned int xid, struct cifsSesInfo *ses, int first_time,
> 
> 	/*	memcpy(bcc_ptr, (char *)ntlm_session_key,LM2_SESS_KEY_SIZE);
> 		bcc_ptr += LM2_SESS_KEY_SIZE; */
>-		memcpy(bcc_ptr, (char *)v2_sess_key, sizeof(struct ntlmv2_resp));
>+		memcpy(bcc_ptr, (char *)v2_sess_key,
>+		       sizeof(struct ntlmv2_resp));
> 		bcc_ptr += sizeof(struct ntlmv2_resp);
> 		kfree(v2_sess_key);
>-		if(ses->capabilities & CAP_UNICODE) {
>-			if(iov[0].iov_len % 2) {
>+		if (ses->capabilities & CAP_UNICODE) {
>+			if (iov[0].iov_len % 2) {
> 				*bcc_ptr = 0;
>-			}	bcc_ptr++;
>+				bcc_ptr++;
>+			}
> 			unicode_ssetup_strings(&bcc_ptr, ses, nls_cp);
> 		} else
> 			ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
>@@ -499,20 +499,20 @@ CIFS_SessSetup(unsigned int xid, struct cifsSesInfo *ses, int first_time,
> 	BCC_LE(smb_buf) = cpu_to_le16(count);
> 
> 	iov[1].iov_base = str_area;
>-	iov[1].iov_len = count; 
>+	iov[1].iov_len = count;
> 	rc = SendReceive2(xid, ses, iov, 2 /* num_iovecs */, &resp_buf_type, 0);
> 	/* SMB request buf freed in SendReceive2 */
> 
>-	cFYI(1,("ssetup rc from sendrecv2 is %d",rc));
>-	if(rc)
>+	cFYI(1, ("ssetup rc from sendrecv2 is %d", rc));
>+	if (rc)
> 		goto ssetup_exit;
> 
> 	pSMB = (SESSION_SETUP_ANDX *)iov[0].iov_base;
> 	smb_buf = (struct smb_hdr *)iov[0].iov_base;
> 
>-	if((smb_buf->WordCount != 3) && (smb_buf->WordCount != 4)) {
>+	if ((smb_buf->WordCount != 3) && (smb_buf->WordCount != 4)) {
> 		rc = -EIO;
>-		cERROR(1,("bad word count %d", smb_buf->WordCount));
>+		cERROR(1, ("bad word count %d", smb_buf->WordCount));
> 		goto ssetup_exit;
> 	}
> 	action = le16_to_cpu(pSMB->resp.Action);
>@@ -525,31 +525,32 @@ CIFS_SessSetup(unsigned int xid, struct cifsSesInfo *ses, int first_time,
> 	bytes_remaining = BCC(smb_buf);
> 	bcc_ptr = pByteArea(smb_buf);
> 
>-	if(smb_buf->WordCount == 4) {
>+	if (smb_buf->WordCount == 4) {
> 		__u16 blob_len;
> 		blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
> 		bcc_ptr += blob_len;
>-		if(blob_len > bytes_remaining) {
>-			cERROR(1,("bad security blob length %d", blob_len));
>+		if (blob_len > bytes_remaining) {
>+			cERROR(1, ("bad security blob length %d", blob_len));
> 			rc = -EINVAL;
> 			goto ssetup_exit;
> 		}
> 		bytes_remaining -= blob_len;
>-	}	
>+	}
> 
> 	/* BB check if Unicode and decode strings */
>-	if(smb_buf->Flags2 & SMBFLG2_UNICODE)
>+	if (smb_buf->Flags2 & SMBFLG2_UNICODE)
> 		rc = decode_unicode_ssetup(&bcc_ptr, bytes_remaining,
> 						   ses, nls_cp);
> 	else
>-		rc = decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses,nls_cp);
>-	
>+		rc = decode_ascii_ssetup(&bcc_ptr, bytes_remaining,
>+					 ses, nls_cp);
>+
> ssetup_exit:
> 	kfree(str_area);
>-	if(resp_buf_type == CIFS_SMALL_BUFFER) {
>-		cFYI(1,("ssetup freeing small buf %p", iov[0].iov_base));
>+	if (resp_buf_type == CIFS_SMALL_BUFFER) {
>+		cFYI(1, ("ssetup freeing small buf %p", iov[0].iov_base));
> 		cifs_small_buf_release(iov[0].iov_base);
>-	} else if(resp_buf_type == CIFS_LARGE_BUFFER)
>+	} else if (resp_buf_type == CIFS_LARGE_BUFFER)
> 		cifs_buf_release(iov[0].iov_base);
> 
> 	return rc;
>diff --git a/fs/cifs/smbdes.c b/fs/cifs/smbdes.c
>index 13e9b83..cfa6d21 100644
>--- a/fs/cifs/smbdes.c
>+++ b/fs/cifs/smbdes.c
>@@ -1,32 +1,32 @@
>-/* 
>+/*
>    Unix SMB/Netbios implementation.
>    Version 1.9.
> 
>-   a partial implementation of DES designed for use in the 
>+   a partial implementation of DES designed for use in the
>    SMB authentication protocol
> 
>    Copyright (C) Andrew Tridgell 1998
>    Modified by Steve French (sfrench@us.ibm.com) 2002,2004
>-   
>+
>    This program is free software; you can redistribute it and/or modify
>    it under the terms of the GNU General Public License as published by
>    the Free Software Foundation; either version 2 of the License, or
>    (at your option) any later version.
>-   
>+
>    This program is distributed in the hope that it will be useful,
>    but WITHOUT ANY WARRANTY; without even the implied warranty of
>    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>    GNU General Public License for more details.
>-   
>+
>    You should have received a copy of the GNU General Public License
>    along with this program; if not, write to the Free Software
>    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
> */
> 
>-/* NOTES: 
>+/* NOTES:
> 
>    This code makes no attempt to be fast! In fact, it is a very
>-   slow implementation 
>+   slow implementation
> 
>    This code is NOT a complete DES implementation. It implements only
>    the minimum necessary for SMB authentication, as used by all SMB
>@@ -153,7 +153,7 @@ static uchar sbox[8][4][16] = {
> };
> 
> static void
>-permute(char *out, char *in, uchar * p, int n)
>+permute(char *out, char *in, uchar *p, int n)
> {
> 	int i;
> 	for (i = 0; i < n; i++)
>@@ -202,18 +202,18 @@ dohash(char *out, char *in, char *key, int forw)
> 	char *rl;
> 
> 	/* Have to reduce stack usage */
>-	pk1 = kmalloc(56+56+64+64,GFP_KERNEL);
>-	if(pk1 == NULL)
>+	pk1 = kmalloc(56+56+64+64, GFP_KERNEL);
>+	if (pk1 == NULL)
> 		return;
> 
> 	ki = kmalloc(16*48, GFP_KERNEL);
>-	if(ki == NULL) {
>+	if (ki == NULL) {
> 		kfree(pk1);
> 		return;
> 	}
> 
> 	cd = pk1 + 56;
>-	pd1= cd  + 56;
>+	pd1 = cd  + 56;
> 	rl = pd1 + 64;
> 
> 	permute(pk1, key, perm1, 56);
>@@ -247,7 +247,7 @@ dohash(char *out, char *in, char *key, int forw)
> 		char *r2;  /* r2[32]  */
> 
> 		er = kmalloc(48+48+32+32+32, GFP_KERNEL);
>-		if(er == NULL) {
>+		if (er == NULL) {
> 			kfree(pk1);
> 			kfree(ki);
> 			return;
>@@ -327,8 +327,8 @@ smbhash(unsigned char *out, unsigned char *in, unsigned char *key, int forw)
> 	char *keyb; /* keyb[64] */
> 	unsigned char key2[8];
> 
>-	outb = kmalloc(64 * 3,GFP_KERNEL);
>-	if(outb == NULL)
>+	outb = kmalloc(64 * 3, GFP_KERNEL);
>+	if (outb == NULL)
> 		return;
> 
> 	inb  = outb + 64;
>@@ -372,20 +372,20 @@ E_P24(unsigned char *p21, unsigned char *c8, unsigned char *p24)
> 	smbhash(p24 + 16, c8, p21 + 14, 1);
> }
> 
>-void
>+#if 0 /* currently unsued */
>+static void
> D_P16(unsigned char *p14, unsigned char *in, unsigned char *out)
> {
> 	smbhash(out, in, p14, 0);
> 	smbhash(out + 8, in + 8, p14 + 7, 0);
> }
> 
>-void
>+static void
> E_old_pw_hash(unsigned char *p14, unsigned char *in, unsigned char *out)
> {
> 	smbhash(out, in, p14, 1);
> 	smbhash(out + 8, in + 8, p14 + 7, 1);
> }
>-#if 0
> /* these routines are currently unneeded, but may be
> 	needed later */
> void
>diff --git a/fs/cifs/smbencrypt.c b/fs/cifs/smbencrypt.c
>index f518c5e..90542a3 100644
>--- a/fs/cifs/smbencrypt.c
>+++ b/fs/cifs/smbencrypt.c
>@@ -1,4 +1,4 @@
>-/* 
>+/*
>    Unix SMB/Netbios implementation.
>    Version 1.9.
>    SMB parameters and setup
>@@ -7,17 +7,17 @@
>    Modified by Jeremy Allison 1995.
>    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2002-2003
>    Modified by Steve French (sfrench@us.ibm.com) 2002-2003
>-   
>+
>    This program is free software; you can redistribute it and/or modify
>    it under the terms of the GNU General Public License as published by
>    the Free Software Foundation; either version 2 of the License, or
>    (at your option) any later version.
>-   
>+
>    This program is distributed in the hope that it will be useful,
>    but WITHOUT ANY WARRANTY; without even the implied warranty of
>    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>    GNU General Public License for more details.
>-   
>+
>    You should have received a copy of the GNU General Public License
>    along with this program; if not, write to the Free Software
>    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
>@@ -51,16 +51,13 @@
> 
> void SMBencrypt(unsigned char *passwd, unsigned char *c8, unsigned char *p24);
> void E_md4hash(const unsigned char *passwd, unsigned char *p16);
>-void nt_lm_owf_gen(char *pwd, unsigned char nt_p16[16], unsigned char p16[16]);
> static void SMBOWFencrypt(unsigned char passwd[16], unsigned char *c8,
> 		   unsigned char p24[24]);
>-void NTLMSSPOWFencrypt(unsigned char passwd[8],
>-		       unsigned char *ntlmchalresp, unsigned char p24[24]);
> void SMBNTencrypt(unsigned char *passwd, unsigned char *c8, unsigned char *p24);
> 
> /*
>    This implements the X/Open SMB password encryption
>-   It takes a password, a 8 byte "crypt key" and puts 24 bytes of 
>+   It takes a password, a 8 byte "crypt key" and puts 24 bytes of
>    encrypted password into p24 */
> /* Note that password must be uppercased and null terminated */
> void
>@@ -76,9 +73,9 @@ SMBencrypt(unsigned char *passwd, unsigned char *c8, unsigned char *p24)
> 	E_P16(p14, p21);
> 
> 	SMBOWFencrypt(p21, c8, p24);
>-	
>-	memset(p14,0,15);
>-	memset(p21,0,21);
>+
>+	memset(p14, 0, 15);
>+	memset(p21, 0, 21);
> }
> 
> /* Routines for Windows NT MD4 Hash functions. */
>@@ -93,14 +90,14 @@ _my_wcslen(__u16 * str)
> 
> /*
>  * Convert a string into an NT UNICODE string.
>- * Note that regardless of processor type 
>+ * Note that regardless of processor type
>  * this must be in intel (little-endian)
>  * format.
>  */
> 
> static int
> _my_mbstowcs(__u16 * dst, const unsigned char *src, int len)
>-{				/* not a very good conversion routine - change/fix */
>+{	/* BB not a very good conversion routine - change/fix */
> 	int i;
> 	__u16 val;
> 
>@@ -115,7 +112,7 @@ _my_mbstowcs(__u16 * dst, const unsigned char *src, int len)
> 	return i;
> }
> 
>-/* 
>+/*
>  * Creates the MD4 Hash of the users password in NT UNICODE.
>  */
> 
>@@ -126,7 +123,7 @@ E_md4hash(const unsigned char *passwd, unsigned char *p16)
> 	__u16 wpwd[129];
> 
> 	/* Password cannot be longer than 128 characters */
>-	if(passwd) {
>+	if (passwd) {
> 		len = strlen((char *) passwd);
> 		if (len > 128) {
> 			len = 128;
>@@ -141,11 +138,12 @@ E_md4hash(const unsigned char *passwd, unsigned char *p16)
> 	len = _my_wcslen(wpwd) * sizeof (__u16);
> 
> 	mdfour(p16, (unsigned char *) wpwd, len);
>-	memset(wpwd,0,129 * 2);
>+	memset(wpwd, 0, 129 * 2);
> }
> 
>+#if 0 /* currently unused */
> /* Does both the NT and LM owfs of a user's password */
>-void
>+static void
> nt_lm_owf_gen(char *pwd, unsigned char nt_p16[16], unsigned char p16[16])
> {
> 	char passwd[514];
>@@ -171,6 +169,7 @@ nt_lm_owf_gen(char *pwd, unsigned char nt_p16[16], unsigned char p16[16])
> 	/* clear out local copy of user's password (just being paranoid). */
> 	memset(passwd, '\0', sizeof (passwd));
> }
>+#endif
> 
> /* Does the NTLMv2 owfs of a user's password */
> #if 0  /* function not needed yet - but will be soon */
>@@ -179,17 +178,17 @@ ntv2_owf_gen(const unsigned char owf[16], const char *user_n,
> 		const char *domain_n, unsigned char kr_buf[16],
> 		const struct nls_table *nls_codepage)
> {
>-	wchar_t * user_u;
>-	wchar_t * dom_u;
>+	wchar_t *user_u;
>+	wchar_t *dom_u;
> 	int user_l, domain_l;
> 	struct HMACMD5Context ctx;
> 
> 	/* might as well do one alloc to hold both (user_u and dom_u) */
>-	user_u = kmalloc(2048 * sizeof(wchar_t),GFP_KERNEL); 
>-	if(user_u == NULL)
>+	user_u = kmalloc(2048 * sizeof(wchar_t), GFP_KERNEL);
>+	if (user_u == NULL)
> 		return;
> 	dom_u = user_u + 1024;
>-    
>+
> 	/* push_ucs2(NULL, user_u, user_n, (user_l+1)*2, STR_UNICODE|STR_NOALIGN|STR_TERMINATE|STR_UPPER);
> 	   push_ucs2(NULL, dom_u, domain_n, (domain_l+1)*2, STR_UNICODE|STR_NOALIGN|STR_TERMINATE|STR_UPPER); */
> 
>@@ -207,7 +206,7 @@ ntv2_owf_gen(const unsigned char owf[16], const char *user_n,
> 
> 	kfree(user_u);
> }
>-#endif 
>+#endif
> 
> /* Does the des encryption from the NT or LM MD4 hash. */
> static void
>@@ -223,7 +222,8 @@ SMBOWFencrypt(unsigned char passwd[16], unsigned char *c8,
> }
> 
> /* Does the des encryption from the FIRST 8 BYTES of the NT or LM MD4 hash. */
>-void
>+#if 0 /* currently unused */
>+static void
> NTLMSSPOWFencrypt(unsigned char passwd[8],
> 		  unsigned char *ntlmchalresp, unsigned char p24[24])
> {
>@@ -235,6 +235,7 @@ NTLMSSPOWFencrypt(unsigned char passwd[8],
> 
> 	E_P24(p21, ntlmchalresp, p24);
> }
>+#endif
> 
> /* Does the NT MD4 hash then des encryption. */
> 
>@@ -255,15 +256,15 @@ SMBNTencrypt(unsigned char *passwd, unsigned char *c8, unsigned char *p24)
> #if 0
> static void
> SMBOWFencrypt_ntv2(const unsigned char kr[16],
>-                   const struct data_blob * srv_chal,
>-                   const struct data_blob * cli_chal, unsigned char resp_buf[16])
>+		   const struct data_blob *srv_chal,
>+		   const struct data_blob *cli_chal, unsigned char resp_buf[16])
> {
>-        struct HMACMD5Context ctx;
>+	struct HMACMD5Context ctx;
> 
>-        hmac_md5_init_limK_to_64(kr, 16, &ctx);
>-        hmac_md5_update(srv_chal->data, srv_chal->length, &ctx);
>-        hmac_md5_update(cli_chal->data, cli_chal->length, &ctx);
>-        hmac_md5_final(resp_buf, &ctx);
>+	hmac_md5_init_limK_to_64(kr, 16, &ctx);
>+	hmac_md5_update(srv_chal->data, srv_chal->length, &ctx);
>+	hmac_md5_update(cli_chal->data, cli_chal->length, &ctx);
>+	hmac_md5_final(resp_buf, &ctx);
> }
> 
> static void
>diff --git a/fs/cifs/smberr.h b/fs/cifs/smberr.h
>index 212c3c2..2ef0be2 100644
>--- a/fs/cifs/smberr.h
>+++ b/fs/cifs/smberr.h
>@@ -4,8 +4,8 @@
>  *   Copyright (c) International Business Machines  Corp., 2002,2004
>  *   Author(s): Steve French (sfrench@us.ibm.com)
>  *
>- *   See Error Codes section of the SNIA CIFS Specification 
>- *   for more information 
>+ *   See Error Codes section of the SNIA CIFS Specification
>+ *   for more information
>  *
>  *   This library is free software; you can redistribute it and/or modify
>  *   it under the terms of the GNU Lesser General Public License as published
>@@ -19,7 +19,7 @@
>  *
>  *   You should have received a copy of the GNU Lesser General Public License
>  *   along with this library; if not, write to the Free Software
>- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
>+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>  */
> 
> #define SUCCESS	0x00	/* The request was successful. */
>@@ -110,7 +110,7 @@
> 
> /* Below errors are used internally (do not come over the wire) for passthrough
>    from STATUS codes to POSIX only  */
>-#define ErrTooManyLinks         0xFFFE   
>+#define ErrTooManyLinks         0xFFFE
> 
> /* Following error codes may be generated with the ERRSRV error class.*/
> 
>diff --git a/fs/cifs/transport.c b/fs/cifs/transport.c
>index 4c4b2b3..3cf3697 100644
>--- a/fs/cifs/transport.c
>+++ b/fs/cifs/transport.c
>@@ -1,10 +1,10 @@
> /*
>  *   fs/cifs/transport.c
>  *
>- *   Copyright (C) International Business Machines  Corp., 2002,2005
>+ *   Copyright (C) International Business Machines  Corp., 2002,2007
>  *   Author(s): Steve French (sfrench@us.ibm.com)
>  *   Jeremy Allison (jra@samba.org) 2006.
>- *    
>+ *
>  *   This library is free software; you can redistribute it and/or modify
>  *   it under the terms of the GNU Lesser General Public License as published
>  *   by the Free Software Foundation; either version 2.1 of the License, or
>@@ -17,7 +17,7 @@
>  *
>  *   You should have received a copy of the GNU Lesser General Public License
>  *   along with this library; if not, write to the Free Software
>- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
>+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>  */
> 
> #include <linux/fs.h>
>@@ -40,7 +40,7 @@ extern kmem_cache_t *cifs_mid_cachep;
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
> extern mempool_t *cifs_mid_poolp;
> #endif
>-extern kmem_cache_t *cifs_oplock_cachep;
>+extern struct kmem_cache *cifs_oplock_cachep;
> 
> static struct mid_q_entry *
> AllocMidQEntry(const struct smb_hdr *smb_buffer, struct cifsSesInfo *ses)
>@@ -58,17 +58,16 @@ AllocMidQEntry(const struct smb_hdr *smb_buffer, struct cifsSesInfo *ses)
> 
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
> 	temp = (struct mid_q_entry *) mempool_alloc(cifs_mid_poolp,
>-						    SLAB_KERNEL | SLAB_NOFS);
>+						    GFP_KERNEL | GFP_NOFS);
> #else
> 	temp = (struct mid_q_entry *) kmem_cache_alloc(cifs_mid_cachep,
> 							SLAB_KERNEL);
>-
> #endif
> 
> 	if (temp == NULL)
> 		return temp;
> 	else {
>-		memset(temp, 0, sizeof (struct mid_q_entry));
>+		memset(temp, 0, sizeof(struct mid_q_entry));
> 		temp->mid = smb_buffer->Mid;	/* always LE */
> 		temp->pid = current->pid;
> 		temp->command = smb_buffer->Command;
>@@ -99,7 +98,7 @@ DeleteMidQEntry(struct mid_q_entry *midEntry)
> 	list_del(&midEntry->qhead);
> 	atomic_dec(&midCount);
> 	spin_unlock(&GlobalMid_Lock);
>-	if(midEntry->largeBuf)
>+	if (midEntry->largeBuf)
> 		cifs_buf_release(midEntry->resp_buf);
> 	else
> 		cifs_small_buf_release(midEntry->resp_buf);
>@@ -107,8 +106,8 @@ DeleteMidQEntry(struct mid_q_entry *midEntry)
> 	now = jiffies;
> 	/* commands taking longer than one second are indications that
> 	   something is wrong, unless it is quite a slow link or server */
>-	if((now - midEntry->when_alloc) > HZ) {
>-		if((cifsFYI & CIFS_TIMER) && 
>+	if ((now - midEntry->when_alloc) > HZ) {
>+		if ((cifsFYI & CIFS_TIMER) &&
> 		   (midEntry->command != SMB_COM_LOCKING_ANDX)) {
> 			printk(KERN_DEBUG " CIFS slow rsp: cmd %d mid %d",
> 			       midEntry->command, midEntry->mid);
>@@ -123,19 +122,19 @@ DeleteMidQEntry(struct mid_q_entry *midEntry)
> 	mempool_free(midEntry, cifs_mid_poolp);
> #else
> 	kmem_cache_free(cifs_mid_cachep, midEntry);
>-#endif
>+#endif	
> }
> 
> struct oplock_q_entry *
>-AllocOplockQEntry(struct inode * pinode, __u16 fid, struct cifsTconInfo * tcon)
>+AllocOplockQEntry(struct inode *pinode, __u16 fid, struct cifsTconInfo *tcon)
> {
> 	struct oplock_q_entry *temp;
>-	if ((pinode== NULL) || (tcon == NULL)) {
>+	if ((pinode == NULL) || (tcon == NULL)) {
> 		cERROR(1, ("Null parms passed to AllocOplockQEntry"));
> 		return NULL;
> 	}
> 	temp = (struct oplock_q_entry *) kmem_cache_alloc(cifs_oplock_cachep,
>-						       SLAB_KERNEL);
>+						       GFP_KERNEL);
> 	if (temp == NULL)
> 		return temp;
> 	else {
>@@ -150,9 +149,9 @@ AllocOplockQEntry(struct inode * pinode, __u16 fid, struct cifsTconInfo * tcon)
> 
> }
> 
>-void DeleteOplockQEntry(struct oplock_q_entry * oplockEntry)
>+void DeleteOplockQEntry(struct oplock_q_entry *oplockEntry)
> {
>-	spin_lock(&GlobalMid_Lock); 
>+	spin_lock(&GlobalMid_Lock);
>     /* should we check if list empty first? */
> 	list_del(&oplockEntry->qhead);
> 	spin_unlock(&GlobalMid_Lock);
>@@ -172,13 +171,13 @@ smb_send(struct socket *ssocket, struct smb_hdr *smb_buffer,
> 	mm_segment_t temp_fs;
> #endif
> 
>-	if(ssocket == NULL)
>+	if (ssocket == NULL)
> 		return -ENOTSOCK; /* BB eventually add reconnect code here */
> 	iov.iov_base = smb_buffer;
> 	iov.iov_len = len;
> 
> 	smb_msg.msg_name = sin;
>-	smb_msg.msg_namelen = sizeof (struct sockaddr);
>+	smb_msg.msg_namelen = sizeof(struct sockaddr);
> #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 8)
> 	smb_msg.msg_iov = &iov;
> 	smb_msg.msg_iovlen = 1;
>@@ -188,8 +187,8 @@ smb_send(struct socket *ssocket, struct smb_hdr *smb_buffer,
> 	smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL; /* BB add more flags?*/
> 
> 	/* smb header is converted in header_assemble. bcc and rest of SMB word
>-	   area, and byte area if necessary, is converted to littleendian in 
>-	   cifssmb.c and RFC1001 len is converted to bigendian in smb_send 
>+	   area, and byte area if necessary, is converted to littleendian in
>+	   cifssmb.c and RFC1001 len is converted to bigendian in smb_send
> 	   Flags2 is converted in SendReceive */
> 
> 	smb_buffer->smb_buf_length = cpu_to_be32(smb_buffer->smb_buf_length);
>@@ -209,9 +208,9 @@ smb_send(struct socket *ssocket, struct smb_hdr *smb_buffer,
> 		if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
> 			i++;
> 		/* smaller timeout here than send2 since smaller size */
>-		/* Although it may not be required, this also is smaller 
>-		   oplock break time */  
>-			if(i > 12) {
>+		/* Although it may not be required, this also is smaller
>+		   oplock break time */
>+			if (i > 12) {
> 				cERROR(1,
> 				   ("sends on sock %p stuck for 7 seconds",
> 				    ssocket));
>@@ -221,7 +220,7 @@ smb_send(struct socket *ssocket, struct smb_hdr *smb_buffer,
> 			msleep(1 << i);
> 			continue;
> 		}
>-		if (rc < 0) 
>+		if (rc < 0)
> 			break;
> 		else
> 			i = 0; /* reset i after each successful send */
>@@ -234,7 +233,7 @@ smb_send(struct socket *ssocket, struct smb_hdr *smb_buffer,
> #endif
> 
> 	if (rc < 0) {
>-		cERROR(1,("Error %d sending data on socket to server", rc));
>+		cERROR(1, ("Error %d sending data on socket to server", rc));
> 	} else {
> 		rc = 0;
> 	}
>@@ -261,19 +260,19 @@ smb_send2(struct socket *ssocket, struct kvec *iov, int n_vec,
> #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 8)
> 	mm_segment_t temp_fs;
> #endif
>-	
>-	if(ssocket == NULL)
>+
>+	if (ssocket == NULL)
> 		return -ENOTSOCK; /* BB eventually add reconnect code here */
> 
> 	smb_msg.msg_name = sin;
>-	smb_msg.msg_namelen = sizeof (struct sockaddr);
>+	smb_msg.msg_namelen = sizeof(struct sockaddr);
> 	smb_msg.msg_control = NULL;
> 	smb_msg.msg_controllen = 0;
> 	smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL; /* BB add more flags?*/
> 
> 	/* smb header is converted in header_assemble. bcc and rest of SMB word
>-	   area, and byte area if necessary, is converted to littleendian in 
>-	   cifssmb.c and RFC1001 len is converted to bigendian in smb_send 
>+	   area, and byte area if necessary, is converted to littleendian in
>+	   cifssmb.c and RFC1001 len is converted to bigendian in smb_send
> 	   Flags2 is converted in SendReceive */
> 
> 
>@@ -300,7 +299,7 @@ smb_send2(struct socket *ssocket, struct kvec *iov, int n_vec,
> #endif
> 		if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
> 			i++;
>-			if(i >= 14) {
>+			if (i >= 14) {
> 				cERROR(1,
> 				   ("sends on sock %p stuck for 15 seconds",
> 				    ssocket));
>@@ -310,22 +309,17 @@ smb_send2(struct socket *ssocket, struct kvec *iov, int n_vec,
> 			msleep(1 << i);
> 			continue;
> 		}
>-		if (rc < 0) 
>+		if (rc < 0)
> 			break;
> 
> 		if (rc >= total_len) {
>-			if(rc > total_len) {
>-				cERROR(1,("unexpected length received"));
>-#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 4, 19)
>-				dump_stack();
>-#endif
>-			}
>+			WARN_ON(rc > total_len);
> 			break;
> 		}
>-		if(rc == 0) {
>+		if (rc == 0) {
> 			/* should never happen, letting socket clear before
> 			   retrying is our only obvious option here */
>-			cERROR(1,("tcp sent no data"));
>+			cERROR(1, ("tcp sent no data"));
> 			msleep(500);
> 			continue;
> 		}
>@@ -351,7 +345,7 @@ smb_send2(struct socket *ssocket, struct kvec *iov, int n_vec,
> #endif
> 
> 	if (rc < 0) {
>-		cERROR(1,("Error %d sending data on socket to server", rc));
>+		cERROR(1, ("Error %d sending data on socket to server", rc));
> 	} else
> 		rc = 0;
> 
>@@ -364,13 +358,13 @@ smb_send2(struct socket *ssocket, struct kvec *iov, int n_vec,
> 
> static int wait_for_free_request(struct cifsSesInfo *ses, const int long_op)
> {
>-	if(long_op == -1) {
>+	if (long_op == -1) {
> 		/* oplock breaks must not be held up */
> 		atomic_inc(&ses->server->inFlight);
> 	} else {
>-		spin_lock(&GlobalMid_Lock); 
>-		while(1) {        
>-			if(atomic_read(&ses->server->inFlight) >= 
>+		spin_lock(&GlobalMid_Lock);
>+		while (1) {
>+			if (atomic_read(&ses->server->inFlight) >=
> 					cifs_max_pending){
> 				spin_unlock(&GlobalMid_Lock);
> #ifdef CONFIG_CIFS_STATS2
>@@ -384,14 +378,14 @@ static int wait_for_free_request(struct cifsSesInfo *ses, const int long_op)
> #endif
> 				spin_lock(&GlobalMid_Lock);
> 			} else {
>-				if(ses->server->tcpStatus == CifsExiting) {
>+				if (ses->server->tcpStatus == CifsExiting) {
> 					spin_unlock(&GlobalMid_Lock);
> 					return -ENOENT;
> 				}
> 
>-				/* can not count locking commands against total since
>-				   they are allowed to block on server */
>-					
>+				/* can not count locking commands against total
>+				   as they are allowed to block on server */
>+
> 				/* update # of requests on the wire to server */
> 				if (long_op < 3)
> 					atomic_inc(&ses->server->inFlight);
>@@ -409,23 +403,22 @@ static int allocate_mid(struct cifsSesInfo *ses, struct smb_hdr *in_buf,
> 	if (ses->server->tcpStatus == CifsExiting) {
> 		return -ENOENT;
> 	} else if (ses->server->tcpStatus == CifsNeedReconnect) {
>-		cFYI(1,("tcp session dead - return to caller to retry"));
>+		cFYI(1, ("tcp session dead - return to caller to retry"));
> 		return -EAGAIN;
> 	} else if (ses->status != CifsGood) {
> 		/* check if SMB session is bad because we are setting it up */
>-		if((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) && 
>+		if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
> 			(in_buf->Command != SMB_COM_NEGOTIATE)) {
> 			return -EAGAIN;
> 		} /* else ok - we are setting up session */
> 	}
> 	*ppmidQ = AllocMidQEntry(in_buf, ses);
>-	if (*ppmidQ == NULL) {
>+	if (*ppmidQ == NULL)
> 		return -ENOMEM;
>-	}
> 	return 0;
> }
> 
>-static int wait_for_response(struct cifsSesInfo *ses, 
>+static int wait_for_response(struct cifsSesInfo *ses,
> 			struct mid_q_entry *midQ,
> 			unsigned long timeout,
> 			unsigned long time_to_wait)
>@@ -435,8 +428,8 @@ static int wait_for_response(struct cifsSesInfo *ses,
> 	for (;;) {
> 		curr_timeout = timeout + jiffies;
> 		wait_event(ses->server->response_q,
>-			(!(midQ->midState == MID_REQUEST_SUBMITTED)) || 
>-			time_after(jiffies, curr_timeout) || 
>+			(!(midQ->midState == MID_REQUEST_SUBMITTED)) ||
>+			time_after(jiffies, curr_timeout) ||
> 			((ses->server->tcpStatus != CifsGood) &&
> 			 (ses->server->tcpStatus != CifsNew)));
> 
>@@ -454,16 +447,16 @@ static int wait_for_response(struct cifsSesInfo *ses,
> 			spin_unlock(&GlobalMid_Lock);
> 
> 			/* Calculate time_to_wait past last receive time.
>-			 Although we prefer not to time out if the 
>+			 Although we prefer not to time out if the
> 			 server is still responding - we will time
>-			 out if the server takes more than 15 (or 45 
>+			 out if the server takes more than 15 (or 45
> 			 or 180) seconds to respond to this request
>-			 and has not responded to any request from 
>+			 and has not responded to any request from
> 			 other threads on the client within 10 seconds */
> 			lrt += time_to_wait;
> 			if (time_after(jiffies, lrt)) {
> 				/* No replies for time_to_wait. */
>-				cERROR(1,("server not responding"));
>+				cERROR(1, ("server not responding"));
> 				return -1;
> 			}
> 		} else {
>@@ -473,8 +466,8 @@ static int wait_for_response(struct cifsSesInfo *ses,
> }
> 
> int
>-SendReceive2(const unsigned int xid, struct cifsSesInfo *ses, 
>-	     struct kvec *iov, int n_vec, int * pRespBufType /* ret */, 
>+SendReceive2(const unsigned int xid, struct cifsSesInfo *ses,
>+	     struct kvec *iov, int n_vec, int *pRespBufType /* ret */,
> 	     const int long_op)
> {
> 	int rc = 0;
>@@ -482,21 +475,21 @@ SendReceive2(const unsigned int xid, struct cifsSesInfo *ses,
> 	unsigned long timeout;
> 	struct mid_q_entry *midQ;
> 	struct smb_hdr *in_buf = iov[0].iov_base;
>-	
>+
> 	*pRespBufType = CIFS_NO_BUFFER;  /* no response buf yet */
> 
> 	if ((ses == NULL) || (ses->server == NULL)) {
> 		cifs_small_buf_release(in_buf);
>-		cERROR(1,("Null session"));
>+		cERROR(1, ("Null session"));
> 		return -EIO;
> 	}
> 
>-	if(ses->server->tcpStatus == CifsExiting) {
>+	if (ses->server->tcpStatus == CifsExiting) {
> 		cifs_small_buf_release(in_buf);
> 		return -ENOENT;
> 	}
> 
>-	/* Ensure that we do not send more than 50 overlapping requests 
>+	/* Ensure that we do not send more than 50 overlapping requests
> 	   to the same server. We may make this configurable later or
> 	   use ses->maxReq */
> 
>@@ -506,23 +499,23 @@ SendReceive2(const unsigned int xid, struct cifsSesInfo *ses,
> 		return rc;
> 	}
> 
>-	/* make sure that we sign in the same order that we send on this socket 
>+	/* make sure that we sign in the same order that we send on this socket
> 	   and avoid races inside tcp sendmsg code that could cause corruption
> 	   of smb data */
> 
>-	down(&ses->server->tcpSem); 
>+	down(&ses->server->tcpSem);
> 
> 	rc = allocate_mid(ses, in_buf, &midQ);
> 	if (rc) {
> 		up(&ses->server->tcpSem);
> 		cifs_small_buf_release(in_buf);
> 		/* Update # of requests on wire to server */
>-		atomic_dec(&ses->server->inFlight); 
>+		atomic_dec(&ses->server->inFlight);
> 		wake_up(&ses->server->request_q);
> 		return rc;
> 	}
> 
>- 	rc = cifs_sign_smb2(iov, n_vec, ses->server, &midQ->sequence_number);
>+	rc = cifs_sign_smb2(iov, n_vec, ses->server, &midQ->sequence_number);
> 
> 	midQ->midState = MID_REQUEST_SUBMITTED;
> #ifdef CONFIG_CIFS_STATS2
>@@ -538,7 +531,7 @@ SendReceive2(const unsigned int xid, struct cifsSesInfo *ses,
> 	up(&ses->server->tcpSem);
> 	cifs_small_buf_release(in_buf);
> 
>-	if(rc < 0)
>+	if (rc < 0)
> 		goto out;
> 
> 	if (long_op == -1)
>@@ -546,18 +539,18 @@ SendReceive2(const unsigned int xid, struct cifsSesInfo *ses,
> 	else if (long_op == 2) /* writes past end of file can take loong time */
> 		timeout = 180 * HZ;
> 	else if (long_op == 1)
>-		timeout = 45 * HZ; /* should be greater than 
>+		timeout = 45 * HZ; /* should be greater than
> 			servers oplock break timeout (about 43 seconds) */
> 	else
> 		timeout = 15 * HZ;
> 
>-	/* wait for 15 seconds or until woken up due to response arriving or 
>+	/* wait for 15 seconds or until woken up due to response arriving or
> 	   due to last connection to this server being unmounted */
> 	if (signal_pending(current)) {
> 		/* if signal pending do not hold up user for full smb timeout
> 		but we still give response a chance to complete */
> 		timeout = 2 * HZ;
>-	}   
>+	}
> 
> 	/* No user interrupts in wait - wreaks havoc with performance */
> 	wait_for_response(ses, midQ, timeout, 10 * HZ);
>@@ -567,10 +560,10 @@ SendReceive2(const unsigned int xid, struct cifsSesInfo *ses,
> 		spin_unlock(&GlobalMid_Lock);
> 		receive_len = midQ->resp_buf->smb_buf_length;
> 	} else {
>-		cERROR(1,("No response to cmd %d mid %d",
>+		cERROR(1, ("No response to cmd %d mid %d",
> 			midQ->command, midQ->mid));
>-		if(midQ->midState == MID_REQUEST_SUBMITTED) {
>-			if(ses->server->tcpStatus == CifsExiting)
>+		if (midQ->midState == MID_REQUEST_SUBMITTED) {
>+			if (ses->server->tcpStatus == CifsExiting)
> 				rc = -EHOSTDOWN;
> 			else {
> 				ses->server->tcpStatus = CifsNeedReconnect;
>@@ -579,9 +572,9 @@ SendReceive2(const unsigned int xid, struct cifsSesInfo *ses,
> 		}
> 
> 		if (rc != -EHOSTDOWN) {
>-			if(midQ->midState == MID_RETRY_NEEDED) {
>+			if (midQ->midState == MID_RETRY_NEEDED) {
> 				rc = -EAGAIN;
>-				cFYI(1,("marking request for retry"));
>+				cFYI(1, ("marking request for retry"));
> 			} else {
> 				rc = -EIO;
> 			}
>@@ -589,21 +582,21 @@ SendReceive2(const unsigned int xid, struct cifsSesInfo *ses,
> 		spin_unlock(&GlobalMid_Lock);
> 		DeleteMidQEntry(midQ);
> 		/* Update # of requests on wire to server */
>-		atomic_dec(&ses->server->inFlight); 
>+		atomic_dec(&ses->server->inFlight);
> 		wake_up(&ses->server->request_q);
> 		return rc;
> 	}
>-  
>+
> 	if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
> 		cERROR(1, ("Frame too large received.  Length: %d  Xid: %d",
> 			receive_len, xid));
> 		rc = -EIO;
> 	} else {		/* rcvd frame is ok */
>-		if (midQ->resp_buf && 
>+		if (midQ->resp_buf &&
> 			(midQ->midState == MID_RESPONSE_RECEIVED)) {
> 
> 			iov[0].iov_base = (char *)midQ->resp_buf;
>-			if(midQ->largeBuf)
>+			if (midQ->largeBuf)
> 				*pRespBufType = CIFS_LARGE_BUFFER;
> 			else
> 				*pRespBufType = CIFS_SMALL_BUFFER;
>@@ -611,14 +604,14 @@ SendReceive2(const unsigned int xid, struct cifsSesInfo *ses,
> 
> 			dump_smb(midQ->resp_buf, 80);
> 			/* convert the length into a more usable form */
>-			if((receive_len > 24) &&
>+			if ((receive_len > 24) &&
> 			   (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
> 					SECMODE_SIGN_ENABLED))) {
> 				rc = cifs_verify_signature(midQ->resp_buf,
>-						ses->server->mac_signing_key,
>+						&ses->server->mac_signing_key,
> 						midQ->sequence_number+1);
>-				if(rc) {
>-					cERROR(1,("Unexpected SMB signature"));
>+				if (rc) {
>+					cERROR(1, ("Unexpected SMB signature"));
> 					/* BB FIXME add code to kill session */
> 				}
> 			}
>@@ -628,23 +621,22 @@ SendReceive2(const unsigned int xid, struct cifsSesInfo *ses,
> 			rc = map_smb_to_linux_error(midQ->resp_buf);
> 
> 			/* convert ByteCount if necessary */
>-			if (receive_len >=
>-			    sizeof (struct smb_hdr) -
>-			    4 /* do not count RFC1001 header */  +
>+			if (receive_len >= sizeof(struct smb_hdr) - 4
>+			    /* do not count RFC1001 header */  +
> 			    (2 * midQ->resp_buf->WordCount) + 2 /* bcc */ )
>-				BCC(midQ->resp_buf) = 
>+				BCC(midQ->resp_buf) =
> 					le16_to_cpu(BCC_LE(midQ->resp_buf));
> 			midQ->resp_buf = NULL;  /* mark it so will not be freed
> 						by DeleteMidQEntry */
> 		} else {
> 			rc = -EIO;
>-			cFYI(1,("Bad MID state?"));
>+			cFYI(1, ("Bad MID state?"));
> 		}
> 	}
> 
> out:
> 	DeleteMidQEntry(midQ);
>-	atomic_dec(&ses->server->inFlight); 
>+	atomic_dec(&ses->server->inFlight);
> 	wake_up(&ses->server->request_q);
> 
> 	return rc;
>@@ -661,18 +653,18 @@ SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
> 	struct mid_q_entry *midQ;
> 
> 	if (ses == NULL) {
>-		cERROR(1,("Null smb session"));
>+		cERROR(1, ("Null smb session"));
> 		return -EIO;
> 	}
>-	if(ses->server == NULL) {
>-		cERROR(1,("Null tcp session"));
>+	if (ses->server == NULL) {
>+		cERROR(1, ("Null tcp session"));
> 		return -EIO;
> 	}
> 
>-	if(ses->server->tcpStatus == CifsExiting)
>+	if (ses->server->tcpStatus == CifsExiting)
> 		return -ENOENT;
> 
>-	/* Ensure that we do not send more than 50 overlapping requests 
>+	/* Ensure that we do not send more than 50 overlapping requests
> 	   to the same server. We may make this configurable later or
> 	   use ses->maxReq */
> 
>@@ -680,17 +672,17 @@ SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
> 	if (rc)
> 		return rc;
> 
>-	/* make sure that we sign in the same order that we send on this socket 
>+	/* make sure that we sign in the same order that we send on this socket
> 	   and avoid races inside tcp sendmsg code that could cause corruption
> 	   of smb data */
> 
>-	down(&ses->server->tcpSem); 
>+	down(&ses->server->tcpSem);
> 
> 	rc = allocate_mid(ses, in_buf, &midQ);
> 	if (rc) {
> 		up(&ses->server->tcpSem);
> 		/* Update # of requests on wire to server */
>-		atomic_dec(&ses->server->inFlight); 
>+		atomic_dec(&ses->server->inFlight);
> 		wake_up(&ses->server->request_q);
> 		return rc;
> 	}
>@@ -701,7 +693,7 @@ SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
> 		DeleteMidQEntry(midQ);
> 		up(&ses->server->tcpSem);
> 		/* Update # of requests on wire to server */
>-		atomic_dec(&ses->server->inFlight); 
>+		atomic_dec(&ses->server->inFlight);
> 		wake_up(&ses->server->request_q);
> 		return -EIO;
> 	}
>@@ -720,7 +712,7 @@ SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
> #endif
> 	up(&ses->server->tcpSem);
> 
>-	if(rc < 0)
>+	if (rc < 0)
> 		goto out;
> 
> 	if (long_op == -1)
>@@ -728,17 +720,17 @@ SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
> 	else if (long_op == 2) /* writes past end of file can take loong time */
> 		timeout = 180 * HZ;
> 	else if (long_op == 1)
>-		timeout = 45 * HZ; /* should be greater than 
>+		timeout = 45 * HZ; /* should be greater than
> 			servers oplock break timeout (about 43 seconds) */
> 	else
> 		timeout = 15 * HZ;
>-	/* wait for 15 seconds or until woken up due to response arriving or 
>+	/* wait for 15 seconds or until woken up due to response arriving or
> 	   due to last connection to this server being unmounted */
> 	if (signal_pending(current)) {
> 		/* if signal pending do not hold up user for full smb timeout
> 		but we still give response a chance to complete */
> 		timeout = 2 * HZ;
>-	}   
>+	}
> 
> 	/* No user interrupts in wait - wreaks havoc with performance */
> 	wait_for_response(ses, midQ, timeout, 10 * HZ);
>@@ -748,10 +740,10 @@ SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
> 		spin_unlock(&GlobalMid_Lock);
> 		receive_len = midQ->resp_buf->smb_buf_length;
> 	} else {
>-		cERROR(1,("No response for cmd %d mid %d",
>+		cERROR(1, ("No response for cmd %d mid %d",
> 			  midQ->command, midQ->mid));
>-		if(midQ->midState == MID_REQUEST_SUBMITTED) {
>-			if(ses->server->tcpStatus == CifsExiting)
>+		if (midQ->midState == MID_REQUEST_SUBMITTED) {
>+			if (ses->server->tcpStatus == CifsExiting)
> 				rc = -EHOSTDOWN;
> 			else {
> 				ses->server->tcpStatus = CifsNeedReconnect;
>@@ -760,9 +752,9 @@ SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
> 		}
> 
> 		if (rc != -EHOSTDOWN) {
>-			if(midQ->midState == MID_RETRY_NEEDED) {
>+			if (midQ->midState == MID_RETRY_NEEDED) {
> 				rc = -EAGAIN;
>-				cFYI(1,("marking request for retry"));
>+				cFYI(1, ("marking request for retry"));
> 			} else {
> 				rc = -EIO;
> 			}
>@@ -770,11 +762,11 @@ SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
> 		spin_unlock(&GlobalMid_Lock);
> 		DeleteMidQEntry(midQ);
> 		/* Update # of requests on wire to server */
>-		atomic_dec(&ses->server->inFlight); 
>+		atomic_dec(&ses->server->inFlight);
> 		wake_up(&ses->server->request_q);
> 		return rc;
> 	}
>-  
>+
> 	if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
> 		cERROR(1, ("Frame too large received.  Length: %d  Xid: %d",
> 			receive_len, xid));
>@@ -790,14 +782,14 @@ SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
> 
> 			dump_smb(out_buf, 92);
> 			/* convert the length into a more usable form */
>-			if((receive_len > 24) &&
>+			if ((receive_len > 24) &&
> 			   (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
> 					SECMODE_SIGN_ENABLED))) {
> 				rc = cifs_verify_signature(out_buf,
>-						ses->server->mac_signing_key,
>+						&ses->server->mac_signing_key,
> 						midQ->sequence_number+1);
>-				if(rc) {
>-					cERROR(1,("Unexpected SMB signature"));
>+				if (rc) {
>+					cERROR(1, ("Unexpected SMB signature"));
> 					/* BB FIXME add code to kill session */
> 				}
> 			}
>@@ -808,20 +800,19 @@ SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
> 			rc = map_smb_to_linux_error(out_buf);
> 
> 			/* convert ByteCount if necessary */
>-			if (receive_len >=
>-			    sizeof (struct smb_hdr) -
>-			    4 /* do not count RFC1001 header */  +
>+			if (receive_len >= sizeof(struct smb_hdr) - 4
>+			    /* do not count RFC1001 header */  +
> 			    (2 * out_buf->WordCount) + 2 /* bcc */ )
> 				BCC(out_buf) = le16_to_cpu(BCC_LE(out_buf));
> 		} else {
> 			rc = -EIO;
>-			cERROR(1,("Bad MID state?"));
>+			cERROR(1, ("Bad MID state?"));
> 		}
> 	}
> 
> out:
> 	DeleteMidQEntry(midQ);
>-	atomic_dec(&ses->server->inFlight); 
>+	atomic_dec(&ses->server->inFlight);
> 	wake_up(&ses->server->request_q);
> 
> 	return rc;
>@@ -839,7 +830,7 @@ send_nt_cancel(struct cifsTconInfo *tcon, struct smb_hdr *in_buf,
> 
> 	header_assemble(in_buf, SMB_COM_NT_CANCEL, tcon, 0);
> 	in_buf->Mid = mid;
>-	down(&ses->server->tcpSem); 
>+	down(&ses->server->tcpSem);
> 	rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
> 	if (rc) {
> 		up(&ses->server->tcpSem);
>@@ -888,20 +879,20 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifsTconInfo *tcon,
> 	struct cifsSesInfo *ses;
> 
> 	if (tcon == NULL || tcon->ses == NULL) {
>-		cERROR(1,("Null smb session"));
>+		cERROR(1, ("Null smb session"));
> 		return -EIO;
> 	}
> 	ses = tcon->ses;
> 
>-	if(ses->server == NULL) {
>-		cERROR(1,("Null tcp session"));
>+	if (ses->server == NULL) {
>+		cERROR(1, ("Null tcp session"));
> 		return -EIO;
> 	}
> 
>-	if(ses->server->tcpStatus == CifsExiting)
>+	if (ses->server->tcpStatus == CifsExiting)
> 		return -ENOENT;
> 
>-	/* Ensure that we do not send more than 50 overlapping requests 
>+	/* Ensure that we do not send more than 50 overlapping requests
> 	   to the same server. We may make this configurable later or
> 	   use ses->maxReq */
> 
>@@ -909,11 +900,11 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifsTconInfo *tcon,
> 	if (rc)
> 		return rc;
> 
>-	/* make sure that we sign in the same order that we send on this socket 
>+	/* make sure that we sign in the same order that we send on this socket
> 	   and avoid races inside tcp sendmsg code that could cause corruption
> 	   of smb data */
> 
>-	down(&ses->server->tcpSem); 
>+	down(&ses->server->tcpSem);
> 
> 	rc = allocate_mid(ses, in_buf, &midQ);
> 	if (rc) {
>@@ -943,14 +934,14 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifsTconInfo *tcon,
> #endif
> 	up(&ses->server->tcpSem);
> 
>-	if(rc < 0) {
>+	if (rc < 0) {
> 		DeleteMidQEntry(midQ);
> 		return rc;
> 	}
> 
> 	/* Wait for a reply - allow signals to interrupt. */
> 	rc = wait_event_interruptible(ses->server->response_q,
>-		(!(midQ->midState == MID_REQUEST_SUBMITTED)) || 
>+		(!(midQ->midState == MID_REQUEST_SUBMITTED)) ||
> 		((ses->server->tcpStatus != CifsGood) &&
> 		 (ses->server->tcpStatus != CifsNew)));
> 
>@@ -984,7 +975,7 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifsTconInfo *tcon,
> 		}
> 
> 		/* Wait 5 seconds for the response. */
>-		if (wait_for_response(ses, midQ, 5 * HZ, 5 * HZ)==0) {
>+		if (wait_for_response(ses, midQ, 5 * HZ, 5 * HZ) == 0) {
> 			/* We got the response - restart system call. */
> 			rstart = 1;
> 		}
>@@ -995,10 +986,10 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifsTconInfo *tcon,
> 		spin_unlock(&GlobalMid_Lock);
> 		receive_len = midQ->resp_buf->smb_buf_length;
> 	} else {
>-		cERROR(1,("No response for cmd %d mid %d",
>+		cERROR(1, ("No response for cmd %d mid %d",
> 			  midQ->command, midQ->mid));
>-		if(midQ->midState == MID_REQUEST_SUBMITTED) {
>-			if(ses->server->tcpStatus == CifsExiting)
>+		if (midQ->midState == MID_REQUEST_SUBMITTED) {
>+			if (ses->server->tcpStatus == CifsExiting)
> 				rc = -EHOSTDOWN;
> 			else {
> 				ses->server->tcpStatus = CifsNeedReconnect;
>@@ -1007,9 +998,9 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifsTconInfo *tcon,
> 		}
> 
> 		if (rc != -EHOSTDOWN) {
>-			if(midQ->midState == MID_RETRY_NEEDED) {
>+			if (midQ->midState == MID_RETRY_NEEDED) {
> 				rc = -EAGAIN;
>-				cFYI(1,("marking request for retry"));
>+				cFYI(1, ("marking request for retry"));
> 			} else {
> 				rc = -EIO;
> 			}
>@@ -1018,7 +1009,7 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifsTconInfo *tcon,
> 		DeleteMidQEntry(midQ);
> 		return rc;
> 	}
>-  
>+
> 	if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
> 		cERROR(1, ("Frame too large received.  Length: %d  Xid: %d",
> 			receive_len, xid));
>@@ -1034,14 +1025,14 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifsTconInfo *tcon,
> 
> 			dump_smb(out_buf, 92);
> 			/* convert the length into a more usable form */
>-			if((receive_len > 24) &&
>+			if ((receive_len > 24) &&
> 			   (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
> 					SECMODE_SIGN_ENABLED))) {
> 				rc = cifs_verify_signature(out_buf,
>-						ses->server->mac_signing_key,
>+						&ses->server->mac_signing_key,
> 						midQ->sequence_number+1);
>-				if(rc) {
>-					cERROR(1,("Unexpected SMB signature"));
>+				if (rc) {
>+					cERROR(1, ("Unexpected SMB signature"));
> 					/* BB FIXME add code to kill session */
> 				}
> 			}
>@@ -1052,14 +1043,13 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifsTconInfo *tcon,
> 			rc = map_smb_to_linux_error(out_buf);
> 
> 			/* convert ByteCount if necessary */
>-			if (receive_len >=
>-			    sizeof (struct smb_hdr) -
>-			    4 /* do not count RFC1001 header */  +
>+			if (receive_len >= sizeof(struct smb_hdr) - 4
>+			    /* do not count RFC1001 header */  +
> 			    (2 * out_buf->WordCount) + 2 /* bcc */ )
> 				BCC(out_buf) = le16_to_cpu(BCC_LE(out_buf));
> 		} else {
> 			rc = -EIO;
>-			cERROR(1,("Bad MID state?"));
>+			cERROR(1, ("Bad MID state?"));
> 		}
> 	}
> 	DeleteMidQEntry(midQ);
>diff --git a/fs/cifs/xattr.c b/fs/cifs/xattr.c
>index 2734a92..8a2a55c 100644
>--- a/fs/cifs/xattr.c
>+++ b/fs/cifs/xattr.c
>@@ -1,7 +1,7 @@
> /*
>  *   fs/cifs/xattr.c
>  *
>- *   Copyright (c) International Business Machines  Corp., 2003
>+ *   Copyright (c) International Business Machines  Corp., 2003, 2007
>  *   Author(s): Steve French (sfrench@us.ibm.com)
>  *
>  *   This library is free software; you can redistribute it and/or modify
>@@ -40,50 +40,52 @@
> #define XATTR_TRUSTED_PREFIX_LEN  8
> #define XATTR_SECURITY_PREFIX_LEN 9
> /* BB need to add server (Samba e.g) support for security and trusted prefix */
>-  
> 
> 
>-int cifs_removexattr(struct dentry * direntry, const char * ea_name)
>+
>+int cifs_removexattr(struct dentry *direntry, const char *ea_name)
> {
> 	int rc = -EOPNOTSUPP;
> #ifdef CONFIG_CIFS_XATTR
> 	int xid;
> 	struct cifs_sb_info *cifs_sb;
> 	struct cifsTconInfo *pTcon;
>-	struct super_block * sb;
>-	char * full_path;
>-                                                                                     
>-	if(direntry == NULL)
>+	struct super_block *sb;
>+	char *full_path;
>+
>+	if (direntry == NULL)
> 		return -EIO;
>-	if(direntry->d_inode == NULL)
>+	if (direntry->d_inode == NULL)
> 		return -EIO;
> 	sb = direntry->d_inode->i_sb;
>-	if(sb == NULL)
>+	if (sb == NULL)
> 		return -EIO;
> 	xid = GetXid();
>-                                                                                     
>+
> 	cifs_sb = CIFS_SB(sb);
> 	pTcon = cifs_sb->tcon;
>-                                                                                     
>+
> 	full_path = build_path_from_dentry(direntry);
>-	if(full_path == NULL) {
>+	if (full_path == NULL) {
> 		FreeXid(xid);
> 		return -ENOMEM;
> 	}
>-	if(ea_name == NULL) {
>-		cFYI(1,("Null xattr names not supported"));
>-	} else if(strncmp(ea_name,CIFS_XATTR_USER_PREFIX,5)
>-		&& (strncmp(ea_name,CIFS_XATTR_OS2_PREFIX,4))) {
>-		cFYI(1,("illegal xattr namespace %s (only user namespace supported)",ea_name));
>+	if (ea_name == NULL) {
>+		cFYI(1, ("Null xattr names not supported"));
>+	} else if (strncmp(ea_name, CIFS_XATTR_USER_PREFIX, 5)
>+		&& (strncmp(ea_name, CIFS_XATTR_OS2_PREFIX, 4))) {
>+		cFYI(1,
>+		    ("illegal xattr request %s (only user namespace supported)",
>+			ea_name));
> 		/* BB what if no namespace prefix? */
> 		/* Should we just pass them to server, except for
> 		system and perhaps security prefixes? */
> 	} else {
>-		if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
>+		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
> 			goto remove_ea_exit;
> 
>-		ea_name+=5; /* skip past user. prefix */
>-		rc = CIFSSMBSetEA(xid,pTcon,full_path,ea_name,NULL,
>+		ea_name += 5; /* skip past user. prefix */
>+		rc = CIFSSMBSetEA(xid, pTcon, full_path, ea_name, NULL,
> 			(__u16)0, cifs_sb->local_nls,
> 			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
> 	}
>@@ -94,23 +96,23 @@ remove_ea_exit:
> 	return rc;
> }
> 
>-int cifs_setxattr(struct dentry * direntry, const char * ea_name,
>-        const void * ea_value, size_t value_size, int flags)
>+int cifs_setxattr(struct dentry *direntry, const char *ea_name,
>+		  const void *ea_value, size_t value_size, int flags)
> {
> 	int rc = -EOPNOTSUPP;
> #ifdef CONFIG_CIFS_XATTR
> 	int xid;
> 	struct cifs_sb_info *cifs_sb;
> 	struct cifsTconInfo *pTcon;
>-	struct super_block * sb;
>-	char * full_path;
>+	struct super_block *sb;
>+	char *full_path;
> 
>-	if(direntry == NULL)
>+	if (direntry == NULL)
> 		return -EIO;
>-	if(direntry->d_inode == NULL)
>+	if (direntry->d_inode == NULL)
> 		return -EIO;
> 	sb = direntry->d_inode->i_sb;
>-	if(sb == NULL)
>+	if (sb == NULL)
> 		return -EIO;
> 	xid = GetXid();
> 
>@@ -118,7 +120,7 @@ int cifs_setxattr(struct dentry * direntry, const char * ea_name,
> 	pTcon = cifs_sb->tcon;
> 
> 	full_path = build_path_from_dentry(direntry);
>-	if(full_path == NULL) {
>+	if (full_path == NULL) {
> 		FreeXid(xid);
> 		return -ENOMEM;
> 	}
>@@ -126,67 +128,69 @@ int cifs_setxattr(struct dentry * direntry, const char * ea_name,
> 	/* return alt name if available as pseudo attr */
> 
> 	/* if proc/fs/cifs/streamstoxattr is set then
>-		search server for EAs or streams to 
>+		search server for EAs or streams to
> 		returns as xattrs */
>-	if(value_size > MAX_EA_VALUE_SIZE) {
>-		cFYI(1,("size of EA value too large"));
>+	if (value_size > MAX_EA_VALUE_SIZE) {
>+		cFYI(1, ("size of EA value too large"));
> 		kfree(full_path);
> 		FreeXid(xid);
> 		return -EOPNOTSUPP;
> 	}
> 
>-	if(ea_name == NULL) {
>-		cFYI(1,("Null xattr names not supported"));
>-	} else if(strncmp(ea_name,CIFS_XATTR_USER_PREFIX,5) == 0) {
>-		if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
>+	if (ea_name == NULL) {
>+		cFYI(1, ("Null xattr names not supported"));
>+	} else if (strncmp(ea_name, CIFS_XATTR_USER_PREFIX, 5) == 0) {
>+		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
> 			goto set_ea_exit;
>-		if(strncmp(ea_name,CIFS_XATTR_DOS_ATTRIB,14) == 0) {
>-			cFYI(1,("attempt to set cifs inode metadata"));
>+		if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0) {
>+			cFYI(1, ("attempt to set cifs inode metadata"));
> 		}
> 		ea_name += 5; /* skip past user. prefix */
>-		rc = CIFSSMBSetEA(xid,pTcon,full_path,ea_name,ea_value,
>+		rc = CIFSSMBSetEA(xid, pTcon, full_path, ea_name, ea_value,
> 			(__u16)value_size, cifs_sb->local_nls,
> 			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
>-	} else if(strncmp(ea_name, CIFS_XATTR_OS2_PREFIX,4) == 0) {
>-		if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
>+	} else if (strncmp(ea_name, CIFS_XATTR_OS2_PREFIX, 4) == 0) {
>+		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
> 			goto set_ea_exit;
> 
> 		ea_name += 4; /* skip past os2. prefix */
>-		rc = CIFSSMBSetEA(xid,pTcon,full_path,ea_name,ea_value,
>+		rc = CIFSSMBSetEA(xid, pTcon, full_path, ea_name, ea_value,
> 			(__u16)value_size, cifs_sb->local_nls,
> 			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
> 	} else {
>-		int temp; 
>-		temp = strncmp(ea_name,POSIX_ACL_XATTR_ACCESS,
>+		int temp;
>+		temp = strncmp(ea_name, POSIX_ACL_XATTR_ACCESS,
> 			strlen(POSIX_ACL_XATTR_ACCESS));
> 		if (temp == 0) {
> #ifdef CONFIG_CIFS_POSIX
>-			if(sb->s_flags & MS_POSIXACL)
>-				rc = CIFSSMBSetPosixACL(xid, pTcon,full_path,
>-					ea_value, (const int)value_size, 
>-					ACL_TYPE_ACCESS,cifs_sb->local_nls,
>-					cifs_sb->mnt_cifs_flags & 
>+			if (sb->s_flags & MS_POSIXACL)
>+				rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
>+					ea_value, (const int)value_size,
>+					ACL_TYPE_ACCESS, cifs_sb->local_nls,
>+					cifs_sb->mnt_cifs_flags &
> 						CIFS_MOUNT_MAP_SPECIAL_CHR);
>-			cFYI(1,("set POSIX ACL rc %d",rc));
>+			cFYI(1, ("set POSIX ACL rc %d", rc));
> #else
>-			cFYI(1,("set POSIX ACL not supported"));
>+			cFYI(1, ("set POSIX ACL not supported"));
> #endif
>-		} else if(strncmp(ea_name,POSIX_ACL_XATTR_DEFAULT,strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
>+		} else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT,
>+				   strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
> #ifdef CONFIG_CIFS_POSIX
>-			if(sb->s_flags & MS_POSIXACL)
>-				rc = CIFSSMBSetPosixACL(xid, pTcon,full_path,
>-					ea_value, (const int)value_size, 
>+			if (sb->s_flags & MS_POSIXACL)
>+				rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
>+					ea_value, (const int)value_size,
> 					ACL_TYPE_DEFAULT, cifs_sb->local_nls,
>-					cifs_sb->mnt_cifs_flags & 
>+					cifs_sb->mnt_cifs_flags &
> 						CIFS_MOUNT_MAP_SPECIAL_CHR);
>-			cFYI(1,("set POSIX default ACL rc %d",rc));
>+			cFYI(1, ("set POSIX default ACL rc %d", rc));
> #else
>-			cFYI(1,("set default POSIX ACL not supported"));
>+			cFYI(1, ("set default POSIX ACL not supported"));
> #endif
> 		} else {
>-			cFYI(1,("illegal xattr request %s (only user namespace supported)",ea_name));
>+			cFYI(1, ("illegal xattr request %s (only user namespace"
>+				 " supported)", ea_name));
> 		  /* BB what if no namespace prefix? */
>-		  /* Should we just pass them to server, except for 
>+		  /* Should we just pass them to server, except for
> 		  system and perhaps security prefixes? */
> 		}
> 	}
>@@ -198,23 +202,23 @@ set_ea_exit:
> 	return rc;
> }
> 
>-ssize_t cifs_getxattr(struct dentry * direntry, const char * ea_name,
>-         void * ea_value, size_t buf_size)
>+ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
>+	void *ea_value, size_t buf_size)
> {
> 	ssize_t rc = -EOPNOTSUPP;
> #ifdef CONFIG_CIFS_XATTR
> 	int xid;
> 	struct cifs_sb_info *cifs_sb;
> 	struct cifsTconInfo *pTcon;
>-	struct super_block * sb;
>-	char * full_path;
>+	struct super_block *sb;
>+	char *full_path;
> 
>-	if(direntry == NULL)
>+	if (direntry == NULL)
> 		return -EIO;
>-	if(direntry->d_inode == NULL)
>+	if (direntry->d_inode == NULL)
> 		return -EIO;
> 	sb = direntry->d_inode->i_sb;
>-	if(sb == NULL)
>+	if (sb == NULL)
> 		return -EIO;
> 
> 	xid = GetXid();
>@@ -223,42 +227,42 @@ ssize_t cifs_getxattr(struct dentry * direntry, const char * ea_name,
> 	pTcon = cifs_sb->tcon;
> 
> 	full_path = build_path_from_dentry(direntry);
>-	if(full_path == NULL) {
>+	if (full_path == NULL) {
> 		FreeXid(xid);
> 		return -ENOMEM;
> 	}
> 	/* return dos attributes as pseudo xattr */
> 	/* return alt name if available as pseudo attr */
>-	if(ea_name == NULL) {
>-		cFYI(1,("Null xattr names not supported"));
>-	} else if(strncmp(ea_name,CIFS_XATTR_USER_PREFIX,5) == 0) {
>-		if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
>+	if (ea_name == NULL) {
>+		cFYI(1, ("Null xattr names not supported"));
>+	} else if (strncmp(ea_name, CIFS_XATTR_USER_PREFIX, 5) == 0) {
>+		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
> 			goto get_ea_exit;
> 
>-		if(strncmp(ea_name,CIFS_XATTR_DOS_ATTRIB,14) == 0) {
>-			cFYI(1,("attempt to query cifs inode metadata"));
>+		if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0) {
>+			cFYI(1, ("attempt to query cifs inode metadata"));
> 			/* revalidate/getattr then populate from inode */
> 		} /* BB add else when above is implemented */
> 		ea_name += 5; /* skip past user. prefix */
>-		rc = CIFSSMBQueryEA(xid,pTcon,full_path,ea_name,ea_value,
>+		rc = CIFSSMBQueryEA(xid, pTcon, full_path, ea_name, ea_value,
> 			buf_size, cifs_sb->local_nls,
> 			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
>-	} else if(strncmp(ea_name, CIFS_XATTR_OS2_PREFIX,4) == 0) {
>-		if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
>+	} else if (strncmp(ea_name, CIFS_XATTR_OS2_PREFIX, 4) == 0) {
>+		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
> 			goto get_ea_exit;
> 
> 		ea_name += 4; /* skip past os2. prefix */
>-		rc = CIFSSMBQueryEA(xid,pTcon,full_path,ea_name,ea_value,
>+		rc = CIFSSMBQueryEA(xid, pTcon, full_path, ea_name, ea_value,
> 			buf_size, cifs_sb->local_nls,
> 			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
>-	} else if(strncmp(ea_name,POSIX_ACL_XATTR_ACCESS,
>+	} else if (strncmp(ea_name, POSIX_ACL_XATTR_ACCESS,
> 			  strlen(POSIX_ACL_XATTR_ACCESS)) == 0) {
> #ifdef CONFIG_CIFS_POSIX
>-		if(sb->s_flags & MS_POSIXACL)
>+		if (sb->s_flags & MS_POSIXACL)
> 			rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
>-				ea_value, buf_size, ACL_TYPE_ACCESS, 
>+				ea_value, buf_size, ACL_TYPE_ACCESS,
> 				cifs_sb->local_nls,
>-				cifs_sb->mnt_cifs_flags & 
>+				cifs_sb->mnt_cifs_flags &
> 					CIFS_MOUNT_MAP_SPECIAL_CHR);
> /*		else if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
> 			__u16 fid;
>@@ -275,39 +279,40 @@ ssize_t cifs_getxattr(struct dentry * direntry, const char * ea_name,
> 				CIFSSMBClose(xid, pTcon, fid);
> 			}
> 		} */  /* BB enable after fixing up return data */
>-                  		
>-#else 
>-		cFYI(1,("query POSIX ACL not supported yet"));
>+#else
>+		cFYI(1, ("query POSIX ACL not supported yet"));
> #endif /* CONFIG_CIFS_POSIX */
>-	} else if(strncmp(ea_name,POSIX_ACL_XATTR_DEFAULT,
>+	} else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT,
> 			  strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
> #ifdef CONFIG_CIFS_POSIX
>-		if(sb->s_flags & MS_POSIXACL)
>+		if (sb->s_flags & MS_POSIXACL)
> 			rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
>-				ea_value, buf_size, ACL_TYPE_DEFAULT, 
>+				ea_value, buf_size, ACL_TYPE_DEFAULT,
> 				cifs_sb->local_nls,
>-				cifs_sb->mnt_cifs_flags & 
>+				cifs_sb->mnt_cifs_flags &
> 					CIFS_MOUNT_MAP_SPECIAL_CHR);
>-#else 
>-		cFYI(1,("query POSIX default ACL not supported yet"));
>+#else
>+		cFYI(1, ("query POSIX default ACL not supported yet"));
> #endif
>-	} else if(strncmp(ea_name,
>-		  CIFS_XATTR_TRUSTED_PREFIX,XATTR_TRUSTED_PREFIX_LEN) == 0) {
>-		cFYI(1,("Trusted xattr namespace not supported yet"));
>-	} else if(strncmp(ea_name,
>-		  CIFS_XATTR_SECURITY_PREFIX,XATTR_SECURITY_PREFIX_LEN) == 0) {
>-		cFYI(1,("Security xattr namespace not supported yet"));
>+	} else if (strncmp(ea_name,
>+		  CIFS_XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) == 0) {
>+		cFYI(1, ("Trusted xattr namespace not supported yet"));
>+	} else if (strncmp(ea_name,
>+		  CIFS_XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) == 0) {
>+		cFYI(1, ("Security xattr namespace not supported yet"));
> 	} else {
>-		cFYI(1,("illegal xattr name request %s (only user namespace supported)",ea_name));
>+		cFYI(1,
>+		    ("illegal xattr request %s (only user namespace supported)",
>+			ea_name));
> 	}
> 
>-	/* We could add an additional check for streams ie 
>+	/* We could add an additional check for streams ie
> 	    if proc/fs/cifs/streamstoxattr is set then
>-		search server for EAs or streams to 
>+		search server for EAs or streams to
> 		returns as xattrs */
> 
>-	if(rc == -EINVAL)
>-		rc = -EOPNOTSUPP; 
>+	if (rc == -EINVAL)
>+		rc = -EOPNOTSUPP;
> 
> get_ea_exit:
> 	kfree(full_path);
>@@ -316,34 +321,34 @@ get_ea_exit:
> 	return rc;
> }
> 
>-ssize_t cifs_listxattr(struct dentry * direntry, char * data, size_t buf_size)
>+ssize_t cifs_listxattr(struct dentry *direntry, char *data, size_t buf_size)
> {
> 	ssize_t rc = -EOPNOTSUPP;
> #ifdef CONFIG_CIFS_XATTR
> 	int xid;
> 	struct cifs_sb_info *cifs_sb;
> 	struct cifsTconInfo *pTcon;
>-	struct super_block * sb;
>-	char * full_path;
>+	struct super_block *sb;
>+	char *full_path;
> 
>-	if(direntry == NULL)
>+	if (direntry == NULL)
> 		return -EIO;
>-	if(direntry->d_inode == NULL)
>+	if (direntry->d_inode == NULL)
> 		return -EIO;
> 	sb = direntry->d_inode->i_sb;
>-	if(sb == NULL)
>+	if (sb == NULL)
> 		return -EIO;
> 
> 	cifs_sb = CIFS_SB(sb);
> 	pTcon = cifs_sb->tcon;
> 
>-	if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
>+	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
> 		return -EOPNOTSUPP;
> 
> 	xid = GetXid();
> 
> 	full_path = build_path_from_dentry(direntry);
>-	if(full_path == NULL) {
>+	if (full_path == NULL) {
> 		FreeXid(xid);
> 		return -ENOMEM;
> 	}
>@@ -351,11 +356,11 @@ ssize_t cifs_listxattr(struct dentry * direntry, char * data, size_t buf_size)
> 	/* return alt name if available as pseudo attr */
> 
> 	/* if proc/fs/cifs/streamstoxattr is set then
>-		search server for EAs or streams to 
>+		search server for EAs or streams to
> 		returns as xattrs */
>-	rc = CIFSSMBQAllEAs(xid,pTcon,full_path,data,buf_size,
>+	rc = CIFSSMBQAllEAs(xid, pTcon, full_path, data, buf_size,
> 				cifs_sb->local_nls,
>-				cifs_sb->mnt_cifs_flags & 
>+				cifs_sb->mnt_cifs_flags &
> 					CIFS_MOUNT_MAP_SPECIAL_CHR);
> 
> 	kfree(full_path);
>-- 
>1.5.3.3
>

Actions: View | Diff

Attachments on bug 417961: 283091 | 283101 | 283111 | 283121 | 283131 | 283141 | 283151 | 283161 | 283171 | 283181 | 283191 | 283201 | 283211 | 283221 | 283231 | 283241 | 283251