Skip to contentSkip to conversation

fs/cifs - Pass cifs_sb->mnt_cifs_flags instead of cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR

PATCH In review Joe Perches 2 participants 5 messages Mar 20, 2008 – Apr 29, 2008

lore
Share & tools
lore
#0 lore raw

PATCH 1/4 fs/cifs - Pass cifs_sb->mnt_cifs_flags instead of cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR

---
 fs/cifs/cifs_dfs_ref.c |    4 +-
 fs/cifs/cifsacl.c      |   10 ++--
 fs/cifs/cifsproto.h    |   71 +++++++++++----------------
 fs/cifs/cifssmb.c      |  124 +++++++++++++++++++++++++----------------------
 fs/cifs/connect.c      |   11 ++--
 fs/cifs/dir.c          |   60 +++++++++++------------
 fs/cifs/fcntl.c        |    7 ++-
 fs/cifs/file.c         |   18 +++----
 fs/cifs/inode.c        |  124 +++++++++++++++++++-----------------------------
 fs/cifs/link.c         |   16 ++----
 fs/cifs/misc.c         |    4 +-
 fs/cifs/readdir.c      |    5 +-
 fs/cifs/xattr.c        |   56 ++++++++++-----------
 13 files changed, 233 insertions(+), 277 deletions(-)
fs/cifs/cifs_dfs_ref.c +2 -2
index 7f88382..453b1de 100644
@@ -325,8 +325,8 @@ cifs_dfs_follow_mountpoint(struct dentry *dentry, struct nameidata *nd)
 	}
 
 	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);
+			  &num_referrals, &referrals,
+			  cifs_sb->mnt_cifs_flags);
 
 	for (i = 0; i < num_referrals; i++) {
 		dump_referral(referrals+i);
fs/cifs/cifsacl.c +4 -6
index f93932c..4fb75af 100644
@@ -588,9 +588,8 @@ static struct cifs_ntsd *get_cifs_acl(u32 *pacllen, struct inode *inode,
 		int oplock = FALSE;
 		/* open file */
 		rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN,
-				READ_CONTROL, 0, &fid, &oplock, NULL,
-				cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
-					CIFS_MOUNT_MAP_SPECIAL_CHR);
+				 READ_CONTROL, 0, &fid, &oplock, NULL,
+				 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags);
 		if (rc != 0) {
 			cERROR(1, ("Unable to open file to get ACL"));
 			FreeXid(xid);
@@ -641,9 +640,8 @@ static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
 		int oplock = FALSE;
 		/* open file */
 		rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN,
-				WRITE_DAC, 0, &fid, &oplock, NULL,
-				cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
-					CIFS_MOUNT_MAP_SPECIAL_CHR);
+				 WRITE_DAC, 0, &fid, &oplock, NULL,
+				 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags);
 		if (rc != 0) {
 			cERROR(1, ("Unable to open file to set ACL"));
 			FreeXid(xid);
fs/cifs/cifsproto.h +29 -42

190 lines not on this page · raw message

fs/cifs/cifssmb.c +66 -58

462 lines not on this page · raw message

fs/cifs/connect.c +5 -6
index 8dbfa97..a951c63 100644
@@ -1408,14 +1408,14 @@ find_unc(__be32 new_target_ip_addr, char *uncName, char *userName)
 int
 connect_to_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
 		    const char *old_path, const struct nls_table *nls_codepage,
-		    int remap)
+		    int cifs_flags)
 {
 	struct dfs_info3_param *referrals = NULL;
 	unsigned int num_referrals;
 	int rc = 0;
 
 	rc = get_dfs_path(xid, pSesInfo, old_path, nls_codepage,
-			&num_referrals, &referrals, remap);
+			&num_referrals, &referrals, cifs_flags);
 
 	/* BB Add in code to: if valid refrl, if not ip address contact
 		the helper that resolves tcp names, mount to it, try to
@@ -1429,7 +1429,7 @@ 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,
-	     struct dfs_info3_param **preferrals, int remap)
+	     struct dfs_info3_param **preferrals, int cifs_flags)
 {
 	char *temp_unc;
 	int rc = 0;
@@ -1457,7 +1457,7 @@ get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
 	}
 	if (rc == 0)
 		rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, &targetUNCs,
-				     pnum_referrals, nls_codepage, remap);
+				     pnum_referrals, nls_codepage, cifs_flags);
 	/* BB map targetUNCs to dfs_info3 structures, here or
 		in CIFSGetDFSRefer BB */
 
@@ -2149,8 +2149,7 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
 					NULL)) {
 					rc = connect_to_dfs_path(xid, pSesInfo,
 						"", cifs_sb->local_nls,
-						cifs_sb->mnt_cifs_flags &
-						  CIFS_MOUNT_MAP_SPECIAL_CHR);
+						cifs_sb->mnt_cifs_flags);
 					rc = -ENODEV;
 					goto out;
 				} else {
fs/cifs/dir.c +29 -31

93 lines not on this page · raw message

fs/cifs/fcntl.c +4 -3
index 7d1d5aa..d345b0b 100644
@@ -89,9 +89,10 @@ int cifs_dir_notify(struct file *file, unsigned long arg)
 	} else {
 		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,
-			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
+				 GENERIC_READ | SYNCHRONIZE,
+				 0 /* create options */,
+				 &netfid, &oplock, NULL, cifs_sb->local_nls,
+				 cifs_sb->mnt_cifs_flags);
 		/* BB fixme - add this handle to a notify handle list */
 		if (rc) {
 			cFYI(1, ("Could not open directory for notify"));
fs/cifs/file.c +8 -10
index fa849c9..b0e7795 100644
@@ -266,18 +266,18 @@ 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,
-			 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
-			 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
-				 & CIFS_MOUNT_MAP_SPECIAL_CHR);
+				 desiredAccess, CREATE_NOT_DIR,
+				 &netfid, &oplock, buf,
+				 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags);
 	else
 		rc = -EIO; /* no NT SMB support fall into legacy open below */
 
 	if (rc == -EIO) {
 		/* Old server, try legacy style OpenX */
 		rc = SMBLegacyOpen(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);
+				   desiredAccess, CREATE_NOT_DIR,
+				   &netfid, &oplock, buf,
+				   cifs_sb->local_nls, cifs_sb->mnt_cifs_flags);
 	}
 	if (rc) {
 		cFYI(1, ("cifs_open returned 0x%x", rc));
@@ -310,8 +310,7 @@ int cifs_open(struct inode *inode, struct file *file)
 					    inode->i_mode,
 					    (__u64)-1, (__u64)-1, 0 /* dev */,
 					    cifs_sb->local_nls,
-					    cifs_sb->mnt_cifs_flags &
-						CIFS_MOUNT_MAP_SPECIAL_CHR);
+					    cifs_sb->mnt_cifs_flags);
 		} else {
 			/* BB implement via Windows security descriptors eg
 			   CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
@@ -414,8 +413,7 @@ reopen_error_exit:
 
 	rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
 			 CREATE_NOT_DIR, &netfid, &oplock, NULL,
-			 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
-				CIFS_MOUNT_MAP_SPECIAL_CHR);
+			 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags);
 	if (rc) {
 		up(&pCifsFile->fh_sem);
 		cFYI(1, ("cifs_open returned 0x%x", rc));
fs/cifs/inode.c +49 -75

311 lines not on this page · raw message

fs/cifs/link.c +6 -10
index 1d6fb01..4b5ca5f 100644
@@ -59,13 +59,11 @@ cifs_hardlink(struct dentry *old_file, struct inode *inode,
 	if (pTcon->unix_ext)
 		rc = CIFSUnixCreateHardLink(xid, pTcon, fromName, toName,
 					    cifs_sb_target->local_nls,
-					    cifs_sb_target->mnt_cifs_flags &
-						CIFS_MOUNT_MAP_SPECIAL_CHR);
+					    cifs_sb_target->mnt_cifs_flags);
 	else {
 		rc = CIFSCreateHardLink(xid, pTcon, fromName, toName,
 					cifs_sb_target->local_nls,
-					cifs_sb_target->mnt_cifs_flags &
-						CIFS_MOUNT_MAP_SPECIAL_CHR);
+					cifs_sb_target->mnt_cifs_flags);
 		if ((rc == -EIO) || (rc == -EINVAL))
 			rc = -EOPNOTSUPP;
 	}
@@ -281,10 +279,9 @@ cifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen)
 		/* 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 &
-					CIFS_MOUNT_MAP_SPECIAL_CHR);
+				 OPEN_REPARSE_POINT, &fid, &oplock, NULL,
+				 cifs_sb->local_nls,
+				 cifs_sb->mnt_cifs_flags);
 		if (!rc) {
 			rc = CIFSSMBQueryReparseLinkInfo(xid, pTcon, full_path,
 				tmpbuffer,
@@ -312,8 +309,7 @@ cifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen)
 						tmp_path,
 						cifs_sb->local_nls,
 						&num_referrals, &refs,
-						cifs_sb->mnt_cifs_flags &
-						    CIFS_MOUNT_MAP_SPECIAL_CHR);
+						cifs_sb->mnt_cifs_flags);
 					cFYI(1, ("Get DFS for %s rc = %d ",
 						tmp_path, rc));
 					if ((num_referrals == 0) && (rc == 0))
fs/cifs/misc.c +2 -2
index 2a42d9f..cd9d977 100644
@@ -714,14 +714,14 @@ cUCS_out:
    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)
+		 const struct nls_table *cp, int cifs_flags)
 {
 	int i, j, charlen;
 	int len_remaining = maxlen;
 	char src_char;
 	__u16 temp;
 
-	if (!mapChars)
+	if (!(cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR))
 		return cifs_strtoUCS(target, source, PATH_MAX, cp);
 
 	for (i = 0, j = 0; i < maxlen; j++) {
fs/cifs/readdir.c +2 -3
index 32b445e..38811ce 100644
@@ -481,9 +481,8 @@ ffirst_retry:
 	}
 
 	rc = CIFSFindFirst(xid, pTcon, full_path, cifs_sb->local_nls,
-		&cifsFile->netfid, &cifsFile->srch_inf,
-		cifs_sb->mnt_cifs_flags &
-			CIFS_MOUNT_MAP_SPECIAL_CHR, CIFS_DIR_SEP(cifs_sb));
+			   &cifsFile->netfid, &cifsFile->srch_inf,
+			   cifs_sb->mnt_cifs_flags, CIFS_DIR_SEP(cifs_sb));
 	if (rc == 0)
 		cifsFile->invalidHandle = FALSE;
 	if ((rc == -EOPNOTSUPP) &&
fs/cifs/xattr.c +27 -29

121 lines not on this page · raw message

Signature · 1 line
1.5.4.rc2
#1 lore raw

PATCH 2/4 fs/cifs - Use bool

---
 fs/cifs/asn1.c       |   10 +++---
 fs/cifs/cifsacl.c    |   16 +++++-----
 fs/cifs/cifsfs.c     |    6 ++--
 fs/cifs/cifsfs.h     |    8 -----
 fs/cifs/cifsglob.h   |   44 +++++++++++----------------
 fs/cifs/cifsproto.h  |   13 ++++----
 fs/cifs/cifssmb.c    |   38 ++++++++++++------------
 fs/cifs/connect.c    |   80 +++++++++++++++++++++++++-------------------------
 fs/cifs/dir.c        |   18 +++++-----
 fs/cifs/fcntl.c      |    2 +-
 fs/cifs/file.c       |   80 +++++++++++++++++++++++++-------------------------
 fs/cifs/inode.c      |   42 +++++++++++++-------------
 fs/cifs/link.c       |    2 +-
 fs/cifs/misc.c       |   33 ++++++++++----------
 fs/cifs/readdir.c    |   12 ++++----
 fs/cifs/smbencrypt.c |    8 ++--
 fs/cifs/xattr.c      |    2 +-
 17 files changed, 200 insertions(+), 214 deletions(-)
fs/cifs/asn1.c +5 -5
index bcda2c6..cb52cbb 100644
@@ -460,8 +460,8 @@ decode_negTokenInit(unsigned char *security_blob, int length,
 	unsigned char *sequence_end;
 	unsigned long *oid = NULL;
 	unsigned int cls, con, tag, oidlen, rc;
-	int use_ntlmssp = FALSE;
-	int use_kerberos = FALSE;
+	bool use_ntlmssp = false;
+	bool use_kerberos = false;
 
 	*secType = NTLM; /* BB eventually make Kerberos or NLTMSSP the default*/
 
@@ -561,15 +561,15 @@ decode_negTokenInit(unsigned char *security_blob, int length,
 					if (compare_oid(oid, oidlen,
 							MSKRB5_OID,
 							MSKRB5_OID_LEN))
-						use_kerberos = TRUE;
+						use_kerberos = true;
 					else if (compare_oid(oid, oidlen,
 							     KRB5_OID,
 							     KRB5_OID_LEN))
-						use_kerberos = TRUE;
+						use_kerberos = true;
 					else if (compare_oid(oid, oidlen,
 							     NTLMSSP_OID,
 							     NTLMSSP_OID_LEN))
-						use_ntlmssp = TRUE;
+						use_ntlmssp = true;
 
 					kfree(oid);
 				}
fs/cifs/cifsacl.c +8 -8
index 4fb75af..feb8dbb 100644
@@ -559,7 +559,7 @@ static struct cifs_ntsd *get_cifs_acl(u32 *pacllen, struct inode *inode,
 				       const char *path)
 {
 	struct cifsFileInfo *open_file;
-	int unlock_file = FALSE;
+	bool unlock_file = false;
 	int xid;
 	int rc = -EIO;
 	__u16 fid;
@@ -582,10 +582,10 @@ static struct cifs_ntsd *get_cifs_acl(u32 *pacllen, struct inode *inode,
 	cifs_sb = CIFS_SB(sb);
 
 	if (open_file) {
-		unlock_file = TRUE;
+		unlock_file = true;
 		fid = open_file->netfid;
 	} else {
-		int oplock = FALSE;
+		int oplock = 0;
 		/* open file */
 		rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN,
 				 READ_CONTROL, 0, &fid, &oplock, NULL,
@@ -599,7 +599,7 @@ static struct cifs_ntsd *get_cifs_acl(u32 *pacllen, struct inode *inode,
 
 	rc = CIFSSMBGetCIFSACL(xid, cifs_sb->tcon, fid, &pntsd, pacllen);
 	cFYI(1, ("GetCIFSACL rc = %d ACL len %d", rc, *pacllen));
-	if (unlock_file == TRUE)
+	if (unlock_file)
 		atomic_dec(&open_file->wrtPending);
 	else
 		CIFSSMBClose(xid, cifs_sb->tcon, fid);
@@ -613,7 +613,7 @@ static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
 				struct inode *inode, const char *path)
 {
 	struct cifsFileInfo *open_file;
-	int unlock_file = FALSE;
+	bool unlock_file = false;
 	int xid;
 	int rc = -EIO;
 	__u16 fid;
@@ -634,10 +634,10 @@ static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
 
 	open_file = find_readable_file(CIFS_I(inode));
 	if (open_file) {
-		unlock_file = TRUE;
+		unlock_file = true;
 		fid = open_file->netfid;
 	} else {
-		int oplock = FALSE;
+		int oplock = 0;
 		/* open file */
 		rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN,
 				 WRITE_DAC, 0, &fid, &oplock, NULL,
@@ -651,7 +651,7 @@ static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
 
 	rc = CIFSSMBSetCIFSACL(xid, cifs_sb->tcon, fid, pnntsd, acllen);
 	cFYI(DBG2, ("SetCIFSACL rc = %d", rc));
-	if (unlock_file == TRUE)
+	if (unlock_file)
 		atomic_dec(&open_file->wrtPending);
 	else
 		CIFSSMBClose(xid, cifs_sb->tcon, fid);
fs/cifs/cifsfs.c +3 -3
index a04b17e..14dceac 100644
@@ -306,8 +306,8 @@ cifs_alloc_inode(struct super_block *sb)
 	/* Until the file is open and we have gotten oplock
 	info back from the server, can not assume caching of
 	file data or metadata */
-	cifs_inode->clientCanCacheRead = FALSE;
-	cifs_inode->clientCanCacheAll = FALSE;
+	cifs_inode->clientCanCacheRead = false;
+	cifs_inode->clientCanCacheAll = false;
 	cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
 
 	/* Can not set i_flags here - they get immediately overwritten
@@ -945,7 +945,7 @@ static int cifs_oplock_thread(void *dummyarg)
 				    rc = CIFSSMBLock(0, pTcon, netfid,
 					    0 /* len */ , 0 /* offset */, 0,
 					    0, LOCKING_ANDX_OPLOCK_RELEASE,
-					    0 /* wait flag */);
+					    false /* wait flag */);
 					cFYI(1, ("Oplock release rc = %d", rc));
 				}
 			} else
fs/cifs/cifsfs.h +0 -8
index 6897830..ab7246a 100644
@@ -24,14 +24,6 @@
 
 #define ROOT_I 2
 
-#ifndef FALSE
-#define FALSE 0
-#endif
-
-#ifndef TRUE
-#define TRUE 1
-#endif
-
 extern struct file_system_type cifs_fs_type;
 extern const struct address_space_operations cifs_addr_ops;
 extern const struct address_space_operations cifs_addr_ops_smallbuf;
fs/cifs/cifsglob.h +18 -26

86 lines not on this page · raw message

fs/cifs/cifsproto.h +7 -6
index eaec2fd..26d33d0 100644
@@ -59,8 +59,9 @@ extern int SendReceiveBlockingLock(const unsigned int xid,
 			struct smb_hdr *out_buf,
 			int *bytes_returned);
 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);
+extern bool is_valid_oplock_break(struct smb_hdr *smb,
+				  struct TCP_Server_Info *);
+extern bool is_size_safe_to_change(struct cifsInodeInfo *, __u64 eof);
 extern struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *);
 #ifdef CONFIG_CIFS_EXPERIMENTAL
 extern struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *);
@@ -189,11 +190,11 @@ extern int CIFSSMBSetAttrLegacy(int xid, struct cifsTconInfo *tcon,
 #endif /* possibly unneeded function */
 extern int CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon,
 			const char *fileName, __u64 size,
-			int setAllocationSizeFlag,
+			bool setAllocationSizeFlag,
 			const struct nls_table *nls_codepage, int cifs_flags);
 extern int CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon,
 			 __u64 size, __u16 fileHandle, __u32 opener_pid,
-			int AllocSizeFlag);
+			bool AllocSizeFlag);
 extern int CIFSSMBUnixSetPerms(const int xid, struct cifsTconInfo *pTcon,
 			char *full_path, __u64 mode, __u64 uid,
 			__u64 gid, dev_t dev,
@@ -283,11 +284,11 @@ extern int CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
 			const __u16 netfid, const __u64 len,
 			const __u64 offset, const __u32 numUnlock,
 			const __u32 numLock, const __u8 lockType,
-			const int waitFlag);
+			const bool 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 __u16 lock_type, const int waitFlag);
+			const __u16 lock_type, const bool waitFlag);
 extern int CIFSSMBTDis(const int xid, struct cifsTconInfo *tcon);
 extern int CIFSSMBLogoff(const int xid, struct cifsSesInfo *ses);
 
fs/cifs/cifssmb.c +19 -19
index 222387c..ee59e93 100644
@@ -95,7 +95,7 @@ static void mark_open_files_invalid(struct cifsTconInfo *pTcon)
 	list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
 		open_file = list_entry(tmp, struct cifsFileInfo, tlist);
 		if (open_file)
-			open_file->invalidHandle = TRUE;
+			open_file->invalidHandle = true;
 	}
 	write_unlock(&GlobalSMBSeslock);
 	/* BB Add call to invalidate_inodes(sb) for all superblocks mounted
@@ -141,7 +141,7 @@ small_smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
 				if (tcon->ses->server->tcpStatus ==
 							CifsNeedReconnect) {
 					/* on "soft" mounts we wait once */
-					if ((tcon->retry == FALSE) ||
+					if (!tcon->retry ||
 					   (tcon->ses->status == CifsExiting)) {
 						cFYI(1, ("gave up waiting on "
 						      "reconnect in smb_init"));
@@ -287,7 +287,7 @@ smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
 				if (tcon->ses->server->tcpStatus ==
 						CifsNeedReconnect) {
 					/* on "soft" mounts we wait once */
-					if ((tcon->retry == FALSE) ||
+					if (!tcon->retry ||
 					   (tcon->ses->status == CifsExiting)) {
 						cFYI(1, ("gave up waiting on "
 						      "reconnect in smb_init"));
@@ -1686,7 +1686,7 @@ int
 CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
 	    const __u16 smb_file_id, const __u64 len,
 	    const __u64 offset, const __u32 numUnlock,
-	    const __u32 numLock, const __u8 lockType, const int waitFlag)
+	    const __u32 numLock, const __u8 lockType, const bool waitFlag)
 {
 	int rc = 0;
 	LOCK_REQ *pSMB = NULL;
@@ -1695,7 +1695,7 @@ CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
 	int timeout = 0;
 	__u16 count;
 
-	cFYI(1, ("CIFSSMBLock timeout %d numLock %d", waitFlag, numLock));
+	cFYI(1, ("CIFSSMBLock timeout %d numLock %d", (int)waitFlag, numLock));
 	rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
 
 	if (rc)
@@ -1706,7 +1706,7 @@ CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
 	if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
 		timeout = CIFS_ASYNC_OP; /* no response expected */
 		pSMB->Timeout = 0;
-	} else if (waitFlag == TRUE) {
+	} else if (waitFlag) {
 		timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
 		pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
 	} else {
@@ -1756,7 +1756,7 @@ 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,
-		const int waitFlag)
+		const bool waitFlag)
 {
 	struct smb_com_transaction2_sfi_req *pSMB  = NULL;
 	struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
@@ -3584,9 +3584,9 @@ findFirstRetry:
 		rc = validate_t2((struct smb_t2_rsp *)pSMBr);
 		if (rc == 0) {
 			if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
-				psrch_inf->unicode = TRUE;
+				psrch_inf->unicode = true;
 			else
-				psrch_inf->unicode = FALSE;
+				psrch_inf->unicode = false;
 
 			psrch_inf->ntwrk_buf_start = (char *)pSMBr;
 			psrch_inf->smallBuf = 0;
@@ -3597,9 +3597,9 @@ findFirstRetry:
 			       le16_to_cpu(pSMBr->t2.ParameterOffset));
 
 			if (parms->EndofSearch)
-				psrch_inf->endOfSearch = TRUE;
+				psrch_inf->endOfSearch = true;
 			else
-				psrch_inf->endOfSearch = FALSE;
+				psrch_inf->endOfSearch = false;
 
 			psrch_inf->entries_in_buffer =
 					le16_to_cpu(parms->SearchCount);
@@ -3627,7 +3627,7 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
 
 	cFYI(1, ("In FindNext"));
 
-	if (psrch_inf->endOfSearch == TRUE)
+	if (psrch_inf->endOfSearch)
 		return -ENOENT;
 
 	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
@@ -3685,7 +3685,7 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
 	cifs_stats_inc(&tcon->num_fnext);
 	if (rc) {
 		if (rc == -EBADF) {
-			psrch_inf->endOfSearch = TRUE;
+			psrch_inf->endOfSearch = true;
 			rc = 0; /* search probably was closed at end of search*/
 		} else
 			cFYI(1, ("FindNext returned = %d", rc));
@@ -3695,9 +3695,9 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
 		if (rc == 0) {
 			/* BB fixme add lock for file (srch_info) struct here */
 			if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
-				psrch_inf->unicode = TRUE;
+				psrch_inf->unicode = true;
 			else
-				psrch_inf->unicode = FALSE;
+				psrch_inf->unicode = false;
 			response_data = (char *) &pSMBr->hdr.Protocol +
 			       le16_to_cpu(pSMBr->t2.ParameterOffset);
 			parms = (T2_FNEXT_RSP_PARMS *)response_data;
@@ -3712,9 +3712,9 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
 			psrch_inf->ntwrk_buf_start = (char *)pSMB;
 			psrch_inf->smallBuf = 0;
 			if (parms->EndofSearch)
-				psrch_inf->endOfSearch = TRUE;
+				psrch_inf->endOfSearch = true;
 			else
-				psrch_inf->endOfSearch = FALSE;
+				psrch_inf->endOfSearch = false;
 			psrch_inf->entries_in_buffer =
 						le16_to_cpu(parms->SearchCount);
 			psrch_inf->index_of_last_entry +=
@@ -4590,7 +4590,7 @@ QFSPosixRetry:
 
 int
 CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon, const char *fileName,
-	      __u64 size, int SetAllocation,
+	      __u64 size, bool SetAllocation,
 	      const struct nls_table *nls_codepage, int cifs_flags)
 {
 	struct smb_com_transaction2_spi_req *pSMB = NULL;
@@ -4679,7 +4679,7 @@ SetEOFRetry:
 
 int
 CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
-		   __u16 fid, __u32 pid_of_opener, int SetAllocation)
+		   __u16 fid, __u32 pid_of_opener, bool SetAllocation)
 {
 	struct smb_com_transaction2_sfi_req *pSMB  = NULL;
 	char *data_offset;
fs/cifs/connect.c +40 -40

183 lines not on this page · raw message

fs/cifs/dir.c +9 -9
index 15fe3b4..6850199 100644
@@ -130,7 +130,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
 	struct cifsFileInfo *pCifsFile = NULL;
 	struct cifsInodeInfo *pCifsInode;
 	int disposition = FILE_OVERWRITE_IF;
-	int write_only = FALSE;
+	bool write_only = false;
 
 	xid = GetXid();
 
@@ -152,7 +152,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
 		if (oflags & FMODE_WRITE) {
 			desiredAccess |= GENERIC_WRITE;
 			if (!(oflags & FMODE_READ))
-				write_only = TRUE;
+				write_only = true;
 		}
 
 		if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
@@ -252,7 +252,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
 			d_instantiate(direntry, newinode);
 		}
 		if ((nd == NULL /* nfsd case - nfs srv does not set nd */) ||
-			((nd->flags & LOOKUP_OPEN) == FALSE)) {
+			(!(nd->flags & LOOKUP_OPEN))) {
 			/* mknod case - do not leave file open */
 			CIFSSMBClose(xid, pTcon, fileHandle);
 		} else if (newinode) {
@@ -264,8 +264,8 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
 			pCifsFile->netfid = fileHandle;
 			pCifsFile->pid = current->tgid;
 			pCifsFile->pInode = newinode;
-			pCifsFile->invalidHandle = FALSE;
-			pCifsFile->closePend     = FALSE;
+			pCifsFile->invalidHandle = false;
+			pCifsFile->closePend     = false;
 			init_MUTEX(&pCifsFile->fh_sem);
 			mutex_init(&pCifsFile->lock_mutex);
 			INIT_LIST_HEAD(&pCifsFile->llist);
@@ -278,7 +278,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
 			pCifsInode = CIFS_I(newinode);
 			if (pCifsInode) {
 				/* if readable file instance put first in list*/
-				if (write_only == TRUE) {
+				if (write_only) {
 					list_add_tail(&pCifsFile->flist,
 						&pCifsInode->openFileList);
 				} else {
@@ -286,12 +286,12 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
 						&pCifsInode->openFileList);
 				}
 				if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
-					pCifsInode->clientCanCacheAll = TRUE;
-					pCifsInode->clientCanCacheRead = TRUE;
+					pCifsInode->clientCanCacheAll = true;
+					pCifsInode->clientCanCacheRead = true;
 					cFYI(1, ("Exclusive Oplock inode %p",
 						newinode));
 				} else if ((oplock & 0xF) == OPLOCK_READ)
-					pCifsInode->clientCanCacheRead = TRUE;
+					pCifsInode->clientCanCacheRead = true;
 			}
 			write_unlock(&GlobalSMBSeslock);
 		}
fs/cifs/fcntl.c +1 -1
index d345b0b..a7cd331 100644
@@ -68,7 +68,7 @@ int cifs_dir_notify(struct file *file, unsigned long arg)
 {
 	int xid;
 	int rc = -EINVAL;
-	int oplock = FALSE;
+	int oplock = 0;
 	struct cifs_sb_info *cifs_sb;
 	struct cifsTconInfo *pTcon;
 	char *full_path = NULL;
fs/cifs/file.c +40 -40

236 lines not on this page · raw message

fs/cifs/inode.c +21 -21

161 lines not on this page · raw message

fs/cifs/link.c +1 -1
index 4b5ca5f..98fa3bc 100644
@@ -228,7 +228,7 @@ cifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen)
 	struct inode *inode = direntry->d_inode;
 	int rc = -EACCES;
 	int xid;
-	int oplock = FALSE;
+	int oplock = 0;
 	struct cifs_sb_info *cifs_sb;
 	struct cifsTconInfo *pTcon;
 	char *full_path = NULL;
fs/cifs/misc.c +17 -16
index cd9d977..a0b02d1 100644
@@ -496,7 +496,8 @@ checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
 	}
 	return 0;
 }
-int
+
+bool
 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;
@@ -522,17 +523,17 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
 				pnotify->Action));  /* BB removeme BB */
 			/*   cifs_dump_mem("Rcvd notify Data: ",buf,
 				sizeof(struct smb_hdr)+60); */
-			return TRUE;
+			return true;
 		}
 		if (pSMBr->hdr.Status.CifsError) {
 			cFYI(1, ("notify err 0x%d",
 				pSMBr->hdr.Status.CifsError));
-			return TRUE;
+			return true;
 		}
-		return FALSE;
+		return false;
 	}
 	if (pSMB->hdr.Command != SMB_COM_LOCKING_ANDX)
-		return FALSE;
+		return false;
 	if (pSMB->hdr.Flags & SMBFLG_RESPONSE) {
 		/* no sense logging error on invalid handle on oplock
 		   break - harmless race between close request and oplock
@@ -541,21 +542,21 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
 		if ((NT_STATUS_INVALID_HANDLE) ==
 		   le32_to_cpu(pSMB->hdr.Status.CifsError)) {
 			cFYI(1, ("invalid handle on oplock break"));
-			return TRUE;
+			return true;
 		} 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" */
+			return false; /* on valid oplock brk we get "request" */
 		}
 	}
 	if (pSMB->hdr.WordCount != 8)
-		return FALSE;
+		return false;
 
 	cFYI(1, ("oplock type 0x%d level 0x%d",
 		 pSMB->LockType, pSMB->OplockLevel));
 	if (!(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE))
-		return FALSE;
+		return false;
 
 	/* look up tcon based on tid & uid */
 	read_lock(&GlobalSMBSeslock);
@@ -573,11 +574,11 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
 					    ("file id match, oplock break"));
 					pCifsInode =
 						CIFS_I(netfile->pInode);
-					pCifsInode->clientCanCacheAll = FALSE;
+					pCifsInode->clientCanCacheAll = false;
 					if (pSMB->OplockLevel == 0)
 						pCifsInode->clientCanCacheRead
-							= FALSE;
-					pCifsInode->oplockPending = TRUE;
+							= false;
+					pCifsInode->oplockPending = true;
 					AllocOplockQEntry(netfile->pInode,
 							  netfile->netfid,
 							  tcon);
@@ -585,17 +586,17 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
 					    ("about to wake up oplock thread"));
 					if (oplockThread)
 					    wake_up_process(oplockThread);
-					return TRUE;
+					return true;
 				}
 			}
 			read_unlock(&GlobalSMBSeslock);
 			cFYI(1, ("No matching file for oplock break"));
-			return TRUE;
+			return true;
 		}
 	}
 	read_unlock(&GlobalSMBSeslock);
 	cFYI(1, ("Can not process oplock break for non-existent connection"));
-	return TRUE;
+	return true;
 }
 
 void
fs/cifs/readdir.c +6 -6
index 38811ce..06dda4b 100644
@@ -447,8 +447,8 @@ static int initiate_cifs_search(const int xid, struct file *file)
 	if (file->private_data == NULL)
 		return -ENOMEM;
 	cifsFile = file->private_data;
-	cifsFile->invalidHandle = TRUE;
-	cifsFile->srch_inf.endOfSearch = FALSE;
+	cifsFile->invalidHandle = true;
+	cifsFile->srch_inf.endOfSearch = false;
 
 	cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 	if (cifs_sb == NULL)
@@ -484,7 +484,7 @@ ffirst_retry:
 			   &cifsFile->netfid, &cifsFile->srch_inf,
 			   cifs_sb->mnt_cifs_flags, CIFS_DIR_SEP(cifs_sb));
 	if (rc == 0)
-		cifsFile->invalidHandle = FALSE;
+		cifsFile->invalidHandle = false;
 	if ((rc == -EOPNOTSUPP) &&
 		(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
 		cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
@@ -669,7 +669,7 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
 	   (index_to_find < first_entry_in_buffer)) {
 		/* close and restart search */
 		cFYI(1, ("search backing up - close and restart search"));
-		cifsFile->invalidHandle = TRUE;
+		cifsFile->invalidHandle = true;
 		CIFSFindClose(xid, pTcon, cifsFile->netfid);
 		kfree(cifsFile->search_resume_name);
 		cifsFile->search_resume_name = NULL;
@@ -691,7 +691,7 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
 	}
 
 	while ((index_to_find >= cifsFile->srch_inf.index_of_last_entry) &&
-	      (rc == 0) && (cifsFile->srch_inf.endOfSearch == FALSE)) {
+	      (rc == 0) && !cifsFile->srch_inf.endOfSearch) {
 		cFYI(1, ("calling findnext2"));
 		rc = CIFSFindNext(xid, pTcon, cifsFile->netfid,
 				  &cifsFile->srch_inf);
@@ -1037,7 +1037,7 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
 				break;
 			}
 		} /* else {
-			cifsFile->invalidHandle = TRUE;
+			cifsFile->invalidHandle = true;
 			CIFSFindClose(xid, pTcon, cifsFile->netfid);
 		}
 		kfree(cifsFile->search_resume_name);
fs/cifs/smbencrypt.c +4 -4
index 58bbfd9..ff3232f 100644
@@ -35,11 +35,11 @@
 #include "cifs_debug.h"
 #include "cifsencrypt.h"
 
-#ifndef FALSE
-#define FALSE 0
+#ifndef false
+#define false 0
 #endif
-#ifndef TRUE
-#define TRUE 1
+#ifndef true
+#define true 1
 #endif
 
 /* following came from the other byteorder.h to avoid include conflicts */
fs/cifs/xattr.c +1 -1
index 5122683..b48680c 100644
@@ -262,7 +262,7 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
 #ifdef CONFIG_CIFS_EXPERIMENTAL
 		else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
 			__u16 fid;
-			int oplock = FALSE;
+			int oplock = 0;
 			struct cifs_ntsd *pacl = NULL;
 			__u32 buflen = 0;
 			if (experimEnabled)
Signature · 1 line
1.5.4.rc2
#2 lore raw

PATCH 3/4 fs/cifs - Remove an indent level, use normal kthread_run arguments

---
 fs/cifs/connect.c |   54 +++++++++++++++++++++++++---------------------------
 1 files changed, 26 insertions(+), 28 deletions(-)
fs/cifs/connect.c +26 -28
index 7c0e1ac..ca16fdc 100644
@@ -330,8 +330,9 @@ static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
 }
 
 static int
-cifs_demultiplex_thread(struct TCP_Server_Info *server)
+cifs_demultiplex_thread(void *data);
 {
+	struct TCP_Server_Info *server = data;
 	int length;
 	unsigned int pdu_length, total_read;
 	struct smb_hdr *smb_buffer = NULL;
@@ -1367,35 +1368,31 @@ find_unc(__be32 new_target_ip_addr, char *uncName, char *userName)
 	list_for_each(tmp, &GlobalTreeConnectionList) {
 		cFYI(1, ("Next tcon"));
 		tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
-		if (tcon->ses) {
-			if (tcon->ses->server) {
-				cFYI(1,
-				     ("old ip addr: %x == new ip %x ?",
-				      tcon->ses->server->addr.sockAddr.sin_addr.
-				      s_addr, new_target_ip_addr));
-				if (tcon->ses->server->addr.sockAddr.sin_addr.
-				    s_addr == new_target_ip_addr) {
+		if (tcon->ses && tcon->ses->server) {
+			cFYI(1,
+			     ("old ip addr: %x == new ip %x ?",
+			      tcon->ses->server->addr.sockAddr.sin_addr.s_addr,
+			      new_target_ip_addr));
+			if (tcon->ses->server->addr.sockAddr.sin_addr.s_addr ==
+			    new_target_ip_addr) {
 	/* BB lock tcon, server and tcp session and increment use count here? */
-					/* found a match on the TCP session */
-					/* BB check if reconnection needed */
+				/* found a match on the TCP session */
+				/* BB check if reconnection needed */
+				cFYI(1,
+				     ("IP match, old UNC: %s new: %s",
+				      tcon->treeName, uncName));
+				if (strncmp(tcon->treeName, uncName,
+					    MAX_TREE_SIZE) == 0) {
 					cFYI(1,
-					      ("IP match, old UNC: %s new: %s",
+					     ("and old usr: %s new: %s",
 					      tcon->treeName, uncName));
-					if (strncmp
-					    (tcon->treeName, uncName,
-					     MAX_TREE_SIZE) == 0) {
-						cFYI(1,
-						     ("and old usr: %s new: %s",
-						      tcon->treeName, uncName));
-						if (strncmp
-						    (tcon->ses->userName,
-						     userName,
-						     MAX_USERNAME_SIZE) == 0) {
-							read_unlock(&GlobalSMBSeslock);
-							/* matched smb session
-							(user name */
-							return tcon;
-						}
+					if (strncmp(tcon->ses->userName,
+						    userName,
+						    MAX_USERNAME_SIZE) == 0) {
+						read_unlock(&GlobalSMBSeslock);
+						/* matched smb session
+						   (user name */
+						return tcon;
 					}
 				}
 			}
@@ -1973,7 +1970,8 @@ 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);
-			srvTcp->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread, srvTcp, "cifsd");
+			srvTcp->tsk = kthread_run(cifs_demultiplex_thread,
+						  srvTcp, "cifsd");
 			if (IS_ERR(srvTcp->tsk)) {
 				rc = PTR_ERR(srvTcp->tsk);
 				cERROR(1, ("error %d create cifsd thread", rc));
Signature · 1 line
1.5.4.rc2
#3 lore raw

PATCH 4/4 fs/cifs - Align case labels to switch

---
 fs/cifs/cifssmb.c |   72 +++++++++++++--------------
 fs/cifs/connect.c |    2 +-
 fs/cifs/ioctl.c   |   72 +++++++++++++-------------
 fs/cifs/misc.c    |  144 ++++++++++++++++++++++++++--------------------------
 4 files changed, 144 insertions(+), 146 deletions(-)
fs/cifs/cifssmb.c +35 -37
index ee59e93..b03403a 100644
@@ -186,14 +186,13 @@ small_smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
 				   know whether we can continue or not without
 				   returning to caller to reset file handle */
 				switch (smb_command) {
-					case SMB_COM_READ_ANDX:
-					case SMB_COM_WRITE_ANDX:
-					case SMB_COM_CLOSE:
-					case SMB_COM_FIND_CLOSE2:
-					case SMB_COM_LOCKING_ANDX: {
-						unload_nls(nls_codepage);
-						return -EAGAIN;
-					}
+				case SMB_COM_READ_ANDX:
+				case SMB_COM_WRITE_ANDX:
+				case SMB_COM_CLOSE:
+				case SMB_COM_FIND_CLOSE2:
+				case SMB_COM_LOCKING_ANDX:
+					unload_nls(nls_codepage);
+					return -EAGAIN;
 				}
 			} else {
 				up(&tcon->ses->sesSem);
@@ -331,14 +330,13 @@ smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
 				   know whether we can continue or not without
 				   returning to caller to reset file handle */
 				switch (smb_command) {
-					case SMB_COM_READ_ANDX:
-					case SMB_COM_WRITE_ANDX:
-					case SMB_COM_CLOSE:
-					case SMB_COM_FIND_CLOSE2:
-					case SMB_COM_LOCKING_ANDX: {
-						unload_nls(nls_codepage);
-						return -EAGAIN;
-					}
+				case SMB_COM_READ_ANDX:
+				case SMB_COM_WRITE_ANDX:
+				case SMB_COM_CLOSE:
+				case SMB_COM_FIND_CLOSE2:
+				case SMB_COM_LOCKING_ANDX:
+					unload_nls(nls_codepage);
+					return -EAGAIN;
 				}
 			} else {
 				up(&tcon->ses->sesSem);
@@ -1139,27 +1137,27 @@ static __u16 convert_disposition(int disposition)
 	__u16 ofun = 0;
 
 	switch (disposition) {
-		case FILE_SUPERSEDE:
-			ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
-			break;
-		case FILE_OPEN:
-			ofun = SMBOPEN_OAPPEND;
-			break;
-		case FILE_CREATE:
-			ofun = SMBOPEN_OCREATE;
-			break;
-		case FILE_OPEN_IF:
-			ofun = SMBOPEN_OCREATE | SMBOPEN_OAPPEND;
-			break;
-		case FILE_OVERWRITE:
-			ofun = SMBOPEN_OTRUNC;
-			break;
-		case FILE_OVERWRITE_IF:
-			ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
-			break;
-		default:
-			cFYI(1, ("unknown disposition %d", disposition));
-			ofun =  SMBOPEN_OAPPEND; /* regular open */
+	case FILE_SUPERSEDE:
+		ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
+		break;
+	case FILE_OPEN:
+		ofun = SMBOPEN_OAPPEND;
+		break;
+	case FILE_CREATE:
+		ofun = SMBOPEN_OCREATE;
+		break;
+	case FILE_OPEN_IF:
+		ofun = SMBOPEN_OCREATE | SMBOPEN_OAPPEND;
+		break;
+	case FILE_OVERWRITE:
+		ofun = SMBOPEN_OTRUNC;
+		break;
+	case FILE_OVERWRITE_IF:
+		ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
+		break;
+	default:
+		cFYI(1, ("unknown disposition %d", disposition));
+		ofun =  SMBOPEN_OAPPEND; /* regular open */
 	}
 	return ofun;
 }
fs/cifs/connect.c +1 -1
index ca16fdc..5544fda 100644
@@ -330,7 +330,7 @@ static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
 }
 
 static int
-cifs_demultiplex_thread(void *data);
+cifs_demultiplex_thread(void *data)
 {
 	struct TCP_Server_Info *server = data;
 	int length;
fs/cifs/ioctl.c +36 -36

82 lines not on this page · raw message

fs/cifs/misc.c +72 -72

162 lines not on this page · raw message

Signature · 1 line
1.5.4.rc2
#4 lore raw

Re: [PATCH 2/4] fs/cifs - Use bool

In reply to Joe Perches

merged - although it required various changes to get it to patch cleanly.

Quoted 1,385 lines · Joe Perches

---

  fs/cifs/asn1.c       |   10 +++---
  fs/cifs/cifsacl.c    |   16 +++++-----
  fs/cifs/cifsfs.c     |    6 ++--
  fs/cifs/cifsfs.h     |    8 -----
  fs/cifs/cifsglob.h   |   44 +++++++++++----------------
  fs/cifs/cifsproto.h  |   13 ++++----
  fs/cifs/cifssmb.c    |   38 ++++++++++++------------
  fs/cifs/connect.c    |   80 +++++++++++++++++++++++++-------------------------
  fs/cifs/dir.c        |   18 +++++-----
  fs/cifs/fcntl.c      |    2 +-
  fs/cifs/file.c       |   80 +++++++++++++++++++++++++-------------------------
  fs/cifs/inode.c      |   42 +++++++++++++-------------
  fs/cifs/link.c       |    2 +-
  fs/cifs/misc.c       |   33 ++++++++++----------
  fs/cifs/readdir.c    |   12 ++++----
  fs/cifs/smbencrypt.c |    8 ++--
  fs/cifs/xattr.c      |    2 +-
  17 files changed, 200 insertions(+), 214 deletions(-)

diff --git a/fs/cifs/asn1.c b/fs/cifs/asn1.c
index bcda2c6..cb52cbb 100644
--- a/fs/cifs/asn1.c
+++ b/fs/cifs/asn1.c
@@ -460,8 +460,8 @@ decode_negTokenInit(unsigned char *security_blob, int length,

        unsigned char *sequence_end;
        unsigned long *oid = NULL;
        unsigned int cls, con, tag, oidlen, rc;
 -       int use_ntlmssp = FALSE;
 -       int use_kerberos = FALSE;
 +       bool use_ntlmssp = false;
 +       bool use_kerberos = false;

*secType = NTLM; /* BB eventually make Kerberos or NLTMSSP the default*/

@@ -561,15 +561,15 @@ decode_negTokenInit(unsigned char *security_blob, int length,

                                        if (compare_oid(oid, oidlen,
                                                        MSKRB5_OID,
                                                        MSKRB5_OID_LEN))
 -                                               use_kerberos = TRUE;
 +                                               use_kerberos = true;
                                        else if (compare_oid(oid, oidlen,
                                                             KRB5_OID,
                                                             KRB5_OID_LEN))

- use_kerberos = TRUE;
+ use_kerberos = true;
else if (compare_oid(oid, oidlen,
NTLMSSP_OID, NTLMSSP_OID_LEN))
- use_ntlmssp = TRUE;
+ use_ntlmssp = true;

                                        kfree(oid);
                                }
 diff --git a/fs/cifs/cifsacl.c b/fs/cifs/cifsacl.c
 index 4fb75af..feb8dbb 100644
 --- a/fs/cifs/cifsacl.c
 +++ b/fs/cifs/cifsacl.c
 @@ -559,7 +559,7 @@ static struct cifs_ntsd *get_cifs_acl(u32 *pacllen, struct inode *inode,
                                       const char *path)
  {
        struct cifsFileInfo *open_file;
 -       int unlock_file = FALSE;
 +       bool unlock_file = false;
        int xid;
        int rc = -EIO;
        __u16 fid;
 @@ -582,10 +582,10 @@ static struct cifs_ntsd *get_cifs_acl(u32 *pacllen, struct inode *inode,
        cifs_sb = CIFS_SB(sb);

        if (open_file) {
 -               unlock_file = TRUE;
 +               unlock_file = true;
                fid = open_file->netfid;
        } else {
 -               int oplock = FALSE;
 +               int oplock = 0;
                /* open file */
                rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN,
                                 READ_CONTROL, 0, &fid, &oplock, NULL,

@@ -599,7 +599,7 @@ static struct cifs_ntsd *get_cifs_acl(u32 *pacllen, struct inode *inode,

        rc = CIFSSMBGetCIFSACL(xid, cifs_sb->tcon, fid, &pntsd, pacllen);
        cFYI(1, ("GetCIFSACL rc = %d ACL len %d", rc, *pacllen));
 -       if (unlock_file == TRUE)
 +       if (unlock_file)
                atomic_dec(&open_file->wrtPending);
        else
                CIFSSMBClose(xid, cifs_sb->tcon, fid);
 @@ -613,7 +613,7 @@ static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
                                struct inode *inode, const char *path)
  {
        struct cifsFileInfo *open_file;
 -       int unlock_file = FALSE;
 +       bool unlock_file = false;
        int xid;
        int rc = -EIO;
        __u16 fid;

@@ -634,10 +634,10 @@ static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,

        open_file = find_readable_file(CIFS_I(inode));
        if (open_file) {
 -               unlock_file = TRUE;
 +               unlock_file = true;
                fid = open_file->netfid;
        } else {
 -               int oplock = FALSE;
 +               int oplock = 0;
                /* open file */
                rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN,
                                 WRITE_DAC, 0, &fid, &oplock, NULL,

@@ -651,7 +651,7 @@ static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,

        rc = CIFSSMBSetCIFSACL(xid, cifs_sb->tcon, fid, pnntsd, acllen);
        cFYI(DBG2, ("SetCIFSACL rc = %d", rc));
 -       if (unlock_file == TRUE)
 +       if (unlock_file)
                atomic_dec(&open_file->wrtPending);
        else
                CIFSSMBClose(xid, cifs_sb->tcon, fid);
 diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
 index a04b17e..14dceac 100644
 --- a/fs/cifs/cifsfs.c
 +++ b/fs/cifs/cifsfs.c
 @@ -306,8 +306,8 @@ cifs_alloc_inode(struct super_block *sb)
        /* Until the file is open and we have gotten oplock
        info back from the server, can not assume caching of
        file data or metadata */
 -       cifs_inode->clientCanCacheRead = FALSE;
 -       cifs_inode->clientCanCacheAll = FALSE;
 +       cifs_inode->clientCanCacheRead = false;
 +       cifs_inode->clientCanCacheAll = false;
        cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */

        /* Can not set i_flags here - they get immediately overwritten
 @@ -945,7 +945,7 @@ static int cifs_oplock_thread(void *dummyarg)
                                    rc = CIFSSMBLock(0, pTcon, netfid,
                                            0 /* len */ , 0 /* offset */, 0,
                                            0, LOCKING_ANDX_OPLOCK_RELEASE,
 -                                           0 /* wait flag */);
 +                                           false /* wait flag */);
                                        cFYI(1, ("Oplock release rc = %d", rc));
                                }
                        } else

diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
index 6897830..ab7246a 100644
--- a/fs/cifs/cifsfs.h
+++ b/fs/cifs/cifsfs.h
@@ -24,14 +24,6 @@

  #define ROOT_I 2

-#ifndef FALSE
-#define FALSE 0
-#endif
-
-#ifndef TRUE
-#define TRUE 1
-#endif
-
extern struct file_system_type cifs_fs_type;
extern const struct address_space_operations cifs_addr_ops; extern const struct address_space_operations cifs_addr_ops_smallbuf;
diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index 69a2e19..b7d9f69 100644
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -57,14 +57,6 @@

  #include "cifspdu.h"

-#ifndef FALSE
-#define FALSE 0
-#endif
-
-#ifndef TRUE
-#define TRUE 1
-#endif
-
#ifndef XATTR_DOS_ATTRIB
#define XATTR_DOS_ATTRIB "user.DOSATTRIB"
#endif

 @@ -147,7 +139,7 @@ struct TCP_Server_Info {
        enum protocolEnum protocolType;
        char versionMajor;
        char versionMinor;
 -       unsigned svlocal:1;     /* local server or remote */
 +       bool svlocal:1;                 /* local server or remote */
        atomic_t socketUseCount; /* number of open cifs sessions on socket */
        atomic_t inFlight;  /* number of requests on the wire to server */
  #ifdef CONFIG_CIFS_STATS2
 @@ -286,10 +278,10 @@ struct cifsTconInfo {
        FILE_SYSTEM_DEVICE_INFO fsDevInfo;
        FILE_SYSTEM_ATTRIBUTE_INFO fsAttrInfo; /* ok if fs name truncated */
        FILE_SYSTEM_UNIX_INFO fsUnixInfo;
 -       unsigned ipc:1;         /* set if connection to IPC$ eg for RPC/PIPES */
 -       unsigned retry:1;
 -       unsigned nocase:1;
 -       unsigned unix_ext:1; /* if off disable Linux extensions to CIFS protocol
 +       bool ipc:1;             /* set if connection to IPC$ eg for RPC/PIPES */
 +       bool retry:1;
 +       bool nocase:1;
 +       bool unix_ext:1;  /* if false disable Linux extensions to CIFS protocol
                                for this mount even if server would support */
        /* BB add field for back pointer to sb struct(s)? */
  };
 @@ -317,10 +309,10 @@ struct cifs_search_info {
        char *srch_entries_start;
        char *presume_name;
        unsigned int resume_name_len;
 -       unsigned endOfSearch:1;
 -       unsigned emptyDir:1;
 -       unsigned unicode:1;
 -       unsigned smallBuf:1; /* so we know which buf_release function to call */
 +       bool endOfSearch:1;
 +       bool emptyDir:1;
 +       bool unicode:1;
 +       bool smallBuf:1; /* so we know which buf_release function to call */

};

struct cifsFileInfo {
@@ -335,9 +327,9 @@ struct cifsFileInfo {
struct inode *pInode; /* needed for oplock break */ struct mutex lock_mutex;
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 */
 -       unsigned messageMode:1;    /* for pipes: message vs byte mode */
 +       bool closePend:1;       /* file is marked to close */
 +       bool invalidHandle:1;   /* file closed via session abend */
 +       bool messageMode:1;     /* for pipes: message vs byte mode */
        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 */
 @@ -356,9 +348,9 @@ struct cifsInodeInfo {
        __u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */
        atomic_t inUse;  /* num concurrent users (local openers cifs) of file*/
        unsigned long time;     /* jiffies of last update/check of inode */
 -       unsigned clientCanCacheRead:1; /* read oplock */
 -       unsigned clientCanCacheAll:1;  /* read and writebehind oplock */
 -       unsigned oplockPending:1;
 +       bool clientCanCacheRead:1;      /* read oplock */
 +       bool clientCanCacheAll:1;       /* read and writebehind oplock */
 +       bool oplockPending:1;
        struct inode vfs_inode;

};

@@ -426,9 +418,9 @@ struct mid_q_entry {
struct smb_hdr *resp_buf; /* response buffer */
int midState; /* wish this were enum but can not pass to wait_event */
__u8 command; /* smb command code */

 -       unsigned largeBuf:1;    /* if valid response, is pointer to large buf */
 -       unsigned multiRsp:1;   /* multiple trans2 responses for one request  */
 -       unsigned multiEnd:1; /* both received */
 +       bool largeBuf:1;        /* if valid response, is pointer to large buf */
 +       bool multiRsp:1;        /* multiple trans2 responses for one request  */
 +       bool multiEnd:1;        /* both received */

};

struct oplock_q_entry {
diff --git a/fs/cifs/cifsproto.h b/fs/cifs/cifsproto.h
index eaec2fd..26d33d0 100644
--- a/fs/cifs/cifsproto.h
+++ b/fs/cifs/cifsproto.h
@@ -59,8 +59,9 @@ extern int SendReceiveBlockingLock(const unsigned int xid,
struct smb_hdr *out_buf,
int *bytes_returned);
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); +extern bool is_valid_oplock_break(struct smb_hdr *smb,
+ struct TCP_Server_Info *);
+extern bool is_size_safe_to_change(struct cifsInodeInfo *, __u64 eof);
extern struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *); #ifdef CONFIG_CIFS_EXPERIMENTAL
extern struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *);
@@ -189,11 +190,11 @@ extern int CIFSSMBSetAttrLegacy(int xid, struct cifsTconInfo *tcon,
#endif /* possibly unneeded function */
extern int CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon,
const char *fileName, __u64 size,
- int setAllocationSizeFlag,
+ bool setAllocationSizeFlag,

                        const struct nls_table *nls_codepage, int cifs_flags);
  extern int CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon,
                         __u64 size, __u16 fileHandle, __u32 opener_pid,
 -                       int AllocSizeFlag);
 +                       bool AllocSizeFlag);
  extern int CIFSSMBUnixSetPerms(const int xid, struct cifsTconInfo *pTcon,
                        char *full_path, __u64 mode, __u64 uid,
                        __u64 gid, dev_t dev,

@@ -283,11 +284,11 @@ extern int CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
const __u16 netfid, const __u64 len,
const __u64 offset, const __u32 numUnlock,
const __u32 numLock, const __u8 lockType,
- const int waitFlag);
+ const bool 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 __u16 lock_type, const int waitFlag);
+ const __u16 lock_type, const bool waitFlag);
extern int CIFSSMBTDis(const int xid, struct cifsTconInfo *tcon); extern int CIFSSMBLogoff(const int xid, struct cifsSesInfo *ses);

diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index 222387c..ee59e93 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -95,7 +95,7 @@ static void mark_open_files_invalid(struct cifsTconInfo *pTcon)

        list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
                open_file = list_entry(tmp, struct cifsFileInfo, tlist);
                if (open_file)
 -                       open_file->invalidHandle = TRUE;
 +                       open_file->invalidHandle = true;
        }
        write_unlock(&GlobalSMBSeslock);
        /* BB Add call to invalidate_inodes(sb) for all superblocks mounted
 @@ -141,7 +141,7 @@ small_smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
                                if (tcon->ses->server->tcpStatus ==
                                                        CifsNeedReconnect) {
                                        /* on "soft" mounts we wait once */
 -                                       if ((tcon->retry == FALSE) ||
 +                                       if (!tcon->retry ||
                                           (tcon->ses->status == CifsExiting)) {
                                                cFYI(1, ("gave up waiting on "
                                                      "reconnect in smb_init"));
 @@ -287,7 +287,7 @@ smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
                                if (tcon->ses->server->tcpStatus ==
                                                CifsNeedReconnect) {
                                        /* on "soft" mounts we wait once */
 -                                       if ((tcon->retry == FALSE) ||
 +                                       if (!tcon->retry ||
                                           (tcon->ses->status == CifsExiting)) {
                                                cFYI(1, ("gave up waiting on "
                                                      "reconnect in smb_init"));
 @@ -1686,7 +1686,7 @@ int
  CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
            const __u16 smb_file_id, const __u64 len,
            const __u64 offset, const __u32 numUnlock,
 -           const __u32 numLock, const __u8 lockType, const int waitFlag)
 +           const __u32 numLock, const __u8 lockType, const bool waitFlag)
  {
        int rc = 0;
        LOCK_REQ *pSMB = NULL;
 @@ -1695,7 +1695,7 @@ CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
        int timeout = 0;
        __u16 count;

- cFYI(1, ("CIFSSMBLock timeout %d numLock %d", waitFlag, numLock));

 +       cFYI(1, ("CIFSSMBLock timeout %d numLock %d", (int)waitFlag, numLock));
        rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);

        if (rc)
 @@ -1706,7 +1706,7 @@ CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
        if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
                timeout = CIFS_ASYNC_OP; /* no response expected */
                pSMB->Timeout = 0;
 -       } else if (waitFlag == TRUE) {
 +       } else if (waitFlag) {
                timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
                pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
        } else {
 @@ -1756,7 +1756,7 @@ 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,
 -               const int waitFlag)
 +               const bool waitFlag)
  {
        struct smb_com_transaction2_sfi_req *pSMB  = NULL;
        struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
 @@ -3584,9 +3584,9 @@ findFirstRetry:
                rc = validate_t2((struct smb_t2_rsp *)pSMBr);
                if (rc == 0) {
                        if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)

- psrch_inf->unicode = TRUE;
+ psrch_inf->unicode = true;
else
- psrch_inf->unicode = FALSE;
+ psrch_inf->unicode = false;

                        psrch_inf->ntwrk_buf_start = (char *)pSMBr;
                        psrch_inf->smallBuf = 0;
 @@ -3597,9 +3597,9 @@ findFirstRetry:
                               le16_to_cpu(pSMBr->t2.ParameterOffset));

                        if (parms->EndofSearch)

- psrch_inf->endOfSearch = TRUE;
+ psrch_inf->endOfSearch = true;
else
- psrch_inf->endOfSearch = FALSE;
+ psrch_inf->endOfSearch = false;

                        psrch_inf->entries_in_buffer =
                                        le16_to_cpu(parms->SearchCount);

@@ -3627,7 +3627,7 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,

        cFYI(1, ("In FindNext"));

- if (psrch_inf->endOfSearch == TRUE)
+ if (psrch_inf->endOfSearch)

                return -ENOENT;

        rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
 @@ -3685,7 +3685,7 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
        cifs_stats_inc(&tcon->num_fnext);
        if (rc) {
                if (rc == -EBADF) {
 -                       psrch_inf->endOfSearch = TRUE;
 +                       psrch_inf->endOfSearch = true;
                        rc = 0; /* search probably was closed at end of search*/
                } else
                        cFYI(1, ("FindNext returned = %d", rc));
 @@ -3695,9 +3695,9 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
                if (rc == 0) {
                        /* BB fixme add lock for file (srch_info) struct here */
                        if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
 -                               psrch_inf->unicode = TRUE;
 +                               psrch_inf->unicode = true;
                        else
 -                               psrch_inf->unicode = FALSE;
 +                               psrch_inf->unicode = false;
                        response_data = (char *) &pSMBr->hdr.Protocol +
                               le16_to_cpu(pSMBr->t2.ParameterOffset);
                        parms = (T2_FNEXT_RSP_PARMS *)response_data;
 @@ -3712,9 +3712,9 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
                        psrch_inf->ntwrk_buf_start = (char *)pSMB;
                        psrch_inf->smallBuf = 0;
                        if (parms->EndofSearch)
 -                               psrch_inf->endOfSearch = TRUE;
 +                               psrch_inf->endOfSearch = true;
                        else
 -                               psrch_inf->endOfSearch = FALSE;
 +                               psrch_inf->endOfSearch = false;
                        psrch_inf->entries_in_buffer =
                                                le16_to_cpu(parms->SearchCount);
                        psrch_inf->index_of_last_entry +=

@@ -4590,7 +4590,7 @@ QFSPosixRetry:

int
CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon, const char *fileName,
- __u64 size, int SetAllocation,
+ __u64 size, bool SetAllocation,
const struct nls_table *nls_codepage, int cifs_flags)

  {
        struct smb_com_transaction2_spi_req *pSMB = NULL;

@@ -4679,7 +4679,7 @@ SetEOFRetry:

int
CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
- __u16 fid, __u32 pid_of_opener, int SetAllocation)
+ __u16 fid, __u32 pid_of_opener, bool SetAllocation)

  {
        struct smb_com_transaction2_sfi_req *pSMB  = NULL;
        char *data_offset;
 diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
 index a951c63..7c0e1ac 100644
 --- a/fs/cifs/connect.c
 +++ b/fs/cifs/connect.c
 @@ -71,23 +71,23 @@ struct smb_vol {
        mode_t file_mode;
        mode_t dir_mode;
        unsigned secFlg;
 -       unsigned rw:1;
 -       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;
 -       unsigned no_xattr:1;   /* set if xattr (EA) support should be disabled*/
 -       unsigned server_ino:1; /* use inode numbers from server ie UniqueId */
 -       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 */
 +       bool rw:1;
 +       bool retry:1;
 +       bool intr:1;
 +       bool setuids:1;
 +       bool override_uid:1;
 +       bool override_gid:1;
 +       bool noperm:1;
 +       bool no_psx_acl:1; /* set if posix acl support should be disabled */
 +       bool cifs_acl:1;
 +       bool no_xattr:1;   /* set if xattr (EA) support should be disabled*/
 +       bool server_ino:1; /* use inode numbers from server ie UniqueId */
 +       bool direct_io:1;
 +       bool remap:1;     /* set to remap seven reserved chars in filenames */
 +       bool posix_paths:1;   /* unset to not ask for posix pathnames. */
 +       bool no_linux_ext:1;
 +       bool sfu_emul:1;
 +       bool nullauth:1; /* attempt to authenticate with null user */
        unsigned nocase;     /* request case insensitive filenames */
        unsigned nobrl;      /* disable sending byte range locks to srv */
        unsigned int rsize;
 @@ -345,8 +345,8 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
        struct task_struct *task_to_wake = NULL;
        struct mid_q_entry *mid_entry;
        char temp;
 -       int isLargeBuf = FALSE;
 -       int isMultiRsp;
 +       bool isLargeBuf = false;
 +       bool isMultiRsp;
        int reconnect;

        current->flags |= PF_MEMALLOC;
 @@ -390,8 +390,8 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                } else /* if existing small buf clear beginning */
                        memset(smallbuf, 0, sizeof(struct smb_hdr));
 -               isLargeBuf = FALSE;
 -               isMultiRsp = FALSE;
 +               isLargeBuf = false;
 +               isMultiRsp = false;
                smb_buffer = smallbuf;
                iov.iov_base = smb_buffer;
                iov.iov_len = 4;
 @@ -517,7 +517,7 @@ incomplete_rcv:
                reconnect = 0;

                if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
 -                       isLargeBuf = TRUE;
 +                       isLargeBuf = true;
                        memcpy(bigbuf, smallbuf, 4);
                        smb_buffer = bigbuf;
                }
 @@ -582,16 +582,18 @@ incomplete_rcv:
                            (mid_entry->command == smb_buffer->Command)) {
                                if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
                                        /* We have a multipart transact2 resp */
 -                                       isMultiRsp = TRUE;
 +                                       isMultiRsp = true;
                                        if (mid_entry->resp_buf) {
                                                /* merge response - fix up 1st*/
                                                if (coalesce_t2(smb_buffer,
                                                        mid_entry->resp_buf)) {
 -                                                       mid_entry->multiRsp = 1;
 +                                                       mid_entry->multiRsp =
 +                                                                true;
                                                        break;
                                                } else {
                                                        /* all parts received */
 -                                                       mid_entry->multiEnd = 1;
 +                                                       mid_entry->multiEnd =
 +                                                                true;
                                                        goto multi_t2_fnd;
                                                }
                                        } else {
 @@ -603,17 +605,15 @@ incomplete_rcv:
                                                        /* Have first buffer */
                                                        mid_entry->resp_buf =
                                                                 smb_buffer;
 -                                                       mid_entry->largeBuf = 1;
 +                                                       mid_entry->largeBuf =
 +                                                                true;
                                                        bigbuf = NULL;
                                                }
                                        }
                                        break;
                                }
                                mid_entry->resp_buf = smb_buffer;
 -                               if (isLargeBuf)
 -                                       mid_entry->largeBuf = 1;
 -                               else
 -                                       mid_entry->largeBuf = 0;
 +                               mid_entry->largeBuf = isLargeBuf;
  multi_t2_fnd:
                                task_to_wake = mid_entry->tsk;
                                mid_entry->midState = MID_RESPONSE_RECEIVED;
 @@ -638,8 +638,8 @@ multi_t2_fnd:
                                        smallbuf = NULL;
                        }
                        wake_up_process(task_to_wake);
 -               } else if ((is_valid_oplock_break(smb_buffer, server) == FALSE)
 -                   && (isMultiRsp == FALSE)) {
 +               } else if (!is_valid_oplock_break(smb_buffer, server) &&
 +                          !isMultiRsp) {
                        cERROR(1, ("No task to wake, unknown frame received! "
                                   "NumMids %d", midCount.counter));
                        cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
 @@ -825,7 +825,7 @@ cifs_parse_mount_options(char *options, const char *devname,
        vol->file_mode = (S_IRWXUGO | S_ISGID) & (~S_IXGRP);

        /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
 -       vol->rw = TRUE;
 +       vol->rw = true;
        /* default is always to request posix paths. */
        vol->posix_paths = 1;

@@ -1181,7 +1181,7 @@ cifs_parse_mount_options(char *options, const char *devname,

                } else if (strnicmp(data, "guest", 5) == 0) {
                        /* ignore */
                } else if (strnicmp(data, "rw", 2) == 0) {
 -                       vol->rw = TRUE;
 +                       vol->rw = true;
                } else if ((strnicmp(data, "suid", 4) == 0) ||
                                   (strnicmp(data, "nosuid", 6) == 0) ||
                                   (strnicmp(data, "exec", 4) == 0) ||
 @@ -1197,7 +1197,7 @@ cifs_parse_mount_options(char *options, const char *devname,
                            is ok to just ignore them */
                        continue;
                } else if (strnicmp(data, "ro", 2) == 0) {
 -                       vol->rw = FALSE;
 +                       vol->rw = false;
                } else if (strnicmp(data, "hard", 4) == 0) {
                        vol->retry = 1;
                } else if (strnicmp(data, "soft", 4) == 0) {

@@ -2601,7 +2601,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, bool *pNTLMv2_flag,
const struct nls_table *nls_codepage)

  {
        struct smb_hdr *smb_buffer;
 @@ -2624,7 +2624,7 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
        if (ses == NULL)
                return -EINVAL;
        domain = ses->domainName;
 -       *pNTLMv2_flag = FALSE;
 +       *pNTLMv2_flag = false;
        smb_buffer = cifs_buf_get();
        if (smb_buffer == NULL) {
                return -ENOMEM;
 @@ -2777,7 +2777,7 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
                                       CIFS_CRYPTO_KEY_SIZE);
                                if (SecurityBlob2->NegotiateFlags &
                                        cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))

- *pNTLMv2_flag = TRUE;
+ *pNTLMv2_flag = true;

                                if ((SecurityBlob2->NegotiateFlags &
                                        cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
 @@ -2938,7 +2938,7 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
  }
  static int
  CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
 -                       char *ntlm_session_key, int ntlmv2_flag,
 +                       char *ntlm_session_key, bool ntlmv2_flag,
                        const struct nls_table *nls_codepage)
  {
        struct smb_hdr *smb_buffer;
 @@ -3567,7 +3567,7 @@ int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
  {
        int rc = 0;
        char ntlm_session_key[CIFS_SESS_KEY_SIZE];
 -       int ntlmv2_flag = FALSE;
 +       bool ntlmv2_flag = false;
        int first_time = 0;

        /* what if server changes its buffer size after dropping the session? */
 diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
 index 15fe3b4..6850199 100644
 --- a/fs/cifs/dir.c
 +++ b/fs/cifs/dir.c
 @@ -130,7 +130,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
        struct cifsFileInfo *pCifsFile = NULL;
        struct cifsInodeInfo *pCifsInode;
        int disposition = FILE_OVERWRITE_IF;

- int write_only = FALSE;
+ bool write_only = false;

        xid = GetXid();

@@ -152,7 +152,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,

                if (oflags & FMODE_WRITE) {
                        desiredAccess |= GENERIC_WRITE;
                        if (!(oflags & FMODE_READ))
 -                               write_only = TRUE;
 +                               write_only = true;
                }

                if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
 @@ -252,7 +252,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                        d_instantiate(direntry, newinode);
                }
                if ((nd == NULL /* nfsd case - nfs srv does not set nd */) ||
 -                       ((nd->flags & LOOKUP_OPEN) == FALSE)) {
 +                       (!(nd->flags & LOOKUP_OPEN))) {
                        /* mknod case - do not leave file open */
                        CIFSSMBClose(xid, pTcon, fileHandle);
                } else if (newinode) {
 @@ -264,8 +264,8 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                        pCifsFile->netfid = fileHandle;
                        pCifsFile->pid = current->tgid;
                        pCifsFile->pInode = newinode;
 -                       pCifsFile->invalidHandle = FALSE;
 -                       pCifsFile->closePend     = FALSE;
 +                       pCifsFile->invalidHandle = false;
 +                       pCifsFile->closePend     = false;
                        init_MUTEX(&pCifsFile->fh_sem);
                        mutex_init(&pCifsFile->lock_mutex);
                        INIT_LIST_HEAD(&pCifsFile->llist);
 @@ -278,7 +278,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                        pCifsInode = CIFS_I(newinode);
                        if (pCifsInode) {
                                /* if readable file instance put first in list*/
 -                               if (write_only == TRUE) {
 +                               if (write_only) {
                                        list_add_tail(&pCifsFile->flist,
                                                &pCifsInode->openFileList);
                                } else {
 @@ -286,12 +286,12 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                                                &pCifsInode->openFileList);
                                }
                                if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
 -                                       pCifsInode->clientCanCacheAll = TRUE;
 -                                       pCifsInode->clientCanCacheRead = TRUE;
 +                                       pCifsInode->clientCanCacheAll = true;
 +                                       pCifsInode->clientCanCacheRead = true;
                                        cFYI(1, ("Exclusive Oplock inode %p",
                                                newinode));
                                } else if ((oplock & 0xF) == OPLOCK_READ)
 -                                       pCifsInode->clientCanCacheRead = TRUE;
 +                                       pCifsInode->clientCanCacheRead = true;
                        }
                        write_unlock(&GlobalSMBSeslock);
                }
 diff --git a/fs/cifs/fcntl.c b/fs/cifs/fcntl.c
 index d345b0b..a7cd331 100644
 --- a/fs/cifs/fcntl.c
 +++ b/fs/cifs/fcntl.c
 @@ -68,7 +68,7 @@ int cifs_dir_notify(struct file *file, unsigned long arg)
  {
        int xid;
        int rc = -EINVAL;
 -       int oplock = FALSE;
 +       int oplock = 0;
        struct cifs_sb_info *cifs_sb;
        struct cifsTconInfo *pTcon;
        char *full_path = NULL;
 diff --git a/fs/cifs/file.c b/fs/cifs/file.c
 index b0e7795..2c3a099 100644
 --- a/fs/cifs/file.c
 +++ b/fs/cifs/file.c
 @@ -51,8 +51,8 @@ static inline struct cifsFileInfo *cifs_init_private(
        INIT_LIST_HEAD(&private_data->llist);
        private_data->pfile = file; /* needed for writepage */
        private_data->pInode = inode;
 -       private_data->invalidHandle = FALSE;
 -       private_data->closePend = FALSE;
 +       private_data->invalidHandle = false;
 +       private_data->closePend = false;
        /* we have to track num writers to the inode, since writepages
        does not tell us which handle the write is for so there can
        be a close (overlapping with write) of the filehandle that
 @@ -148,12 +148,12 @@ client_can_cache:
                        full_path, buf, inode->i_sb, xid);

        if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
 -               pCifsInode->clientCanCacheAll = TRUE;
 -               pCifsInode->clientCanCacheRead = TRUE;
 +               pCifsInode->clientCanCacheAll = true;
 +               pCifsInode->clientCanCacheRead = true;
                cFYI(1, ("Exclusive Oplock granted on inode %p",
                         file->f_path.dentry->d_inode));
        } else if ((*oplock & 0xF) == OPLOCK_READ)

- pCifsInode->clientCanCacheRead = TRUE;
+ pCifsInode->clientCanCacheRead = true;

        return rc;
  }
 @@ -247,7 +247,7 @@ int cifs_open(struct inode *inode, struct file *file)
        if (oplockEnabled)
                oplock = REQ_OPLOCK;
        else

- oplock = FALSE;
+ oplock = 0;

        /* BB pass O_SYNC flag through on file attributes .. BB */

@@ -338,7 +338,7 @@ static int cifs_relock_file(struct cifsFileInfo *cifsFile)

        return rc;

}

-static int cifs_reopen_file(struct file *file, int can_flush) +static int cifs_reopen_file(struct file *file, bool can_flush)

  {
        int rc = -EACCES;
        int xid, oplock;

@@ -359,7 +359,7 @@ static int cifs_reopen_file(struct file *file, int can_flush)

        xid = GetXid();
        down(&pCifsFile->fh_sem);
 -       if (pCifsFile->invalidHandle == FALSE) {
 +       if (!pCifsFile->invalidHandle) {
                up(&pCifsFile->fh_sem);
                FreeXid(xid);
                return 0;
 @@ -403,7 +403,7 @@ reopen_error_exit:
        if (oplockEnabled)
                oplock = REQ_OPLOCK;
        else

- oplock = FALSE;
+ oplock = 0;

/* Can not refresh inode by passing in file_info buf to be returned
by SMBOpen and then calling get_inode_info with returned buf
@@ -420,7 +420,7 @@ reopen_error_exit:

                cFYI(1, ("oplock: %d", oplock));
        } else {
                pCifsFile->netfid = netfid;
 -               pCifsFile->invalidHandle = FALSE;
 +               pCifsFile->invalidHandle = false;
                up(&pCifsFile->fh_sem);
                pCifsInode = CIFS_I(inode);
                if (pCifsInode) {
 @@ -430,8 +430,8 @@ reopen_error_exit:
                                        CIFS_I(inode)->write_behind_rc = rc;
                        /* temporarily disable caching while we
                           go to server to get inode info */
 -                               pCifsInode->clientCanCacheAll = FALSE;
 -                               pCifsInode->clientCanCacheRead = FALSE;
 +                               pCifsInode->clientCanCacheAll = false;
 +                               pCifsInode->clientCanCacheRead = false;
                                if (pTcon->unix_ext)
                                        rc = cifs_get_inode_info_unix(&inode,
                                                full_path, inode->i_sb, xid);
 @@ -446,16 +446,16 @@ reopen_error_exit:
                             we can not go to the server to get the new inod
                             info */
                        if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
 -                               pCifsInode->clientCanCacheAll = TRUE;
 -                               pCifsInode->clientCanCacheRead = TRUE;
 +                               pCifsInode->clientCanCacheAll = true;
 +                               pCifsInode->clientCanCacheRead = true;
                                cFYI(1, ("Exclusive Oplock granted on inode %p",
                                         file->f_path.dentry->d_inode));
                        } else if ((oplock & 0xF) == OPLOCK_READ) {
 -                               pCifsInode->clientCanCacheRead = TRUE;
 -                               pCifsInode->clientCanCacheAll = FALSE;
 +                               pCifsInode->clientCanCacheRead = true;
 +                               pCifsInode->clientCanCacheAll = false;
                        } else {
 -                               pCifsInode->clientCanCacheRead = FALSE;
 -                               pCifsInode->clientCanCacheAll = FALSE;
 +                               pCifsInode->clientCanCacheRead = false;
 +                               pCifsInode->clientCanCacheAll = false;
                        }
                        cifs_relock_file(pCifsFile);
                }
 @@ -482,7 +482,7 @@ int cifs_close(struct inode *inode, struct file *file)
        if (pSMBFile) {
                struct cifsLockInfo *li, *tmp;

- pSMBFile->closePend = TRUE;

 +               pSMBFile->closePend = true;
                if (pTcon) {
                        /* no sense reconnecting to close a file that is
                           already closed */
 @@ -551,8 +551,8 @@ int cifs_close(struct inode *inode, struct file *file)
                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
                   on this inode, much less write behind and read ahead */
 -               CIFS_I(inode)->clientCanCacheRead = FALSE;
 -               CIFS_I(inode)->clientCanCacheAll  = FALSE;
 +               CIFS_I(inode)->clientCanCacheRead = false;
 +               CIFS_I(inode)->clientCanCacheAll  = false;
        }
        read_unlock(&GlobalSMBSeslock);
        if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
 @@ -581,9 +581,9 @@ int cifs_closedir(struct inode *inode, struct file *file)
                pTcon = cifs_sb->tcon;

                cFYI(1, ("Freeing private data in close dir"));
 -               if ((pCFileStruct->srch_inf.endOfSearch == FALSE) &&
 -                  (pCFileStruct->invalidHandle == FALSE)) {
 -                       pCFileStruct->invalidHandle = TRUE;
 +               if (!pCFileStruct->srch_inf.endOfSearch &&
 +                   !pCFileStruct->invalidHandle) {
 +                       pCFileStruct->invalidHandle = true;
                        rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
                        cFYI(1, ("Closing uncompleted readdir with rc %d",
                                 rc));
 @@ -635,12 +635,12 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
        __u32 numLock = 0;
        __u32 numUnlock = 0;
        __u64 length;
 -       int wait_flag = FALSE;
 +       bool wait_flag = false;
        struct cifs_sb_info *cifs_sb;
        struct cifsTconInfo *pTcon;
        __u16 netfid;
        __u8 lockType = LOCKING_ANDX_LARGE_FILES;

- int posix_locking;
+ bool posix_locking;

        length = 1 + pfLock->fl_end - pfLock->fl_start;
        rc = -EACCES;
 @@ -657,7 +657,7 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
                cFYI(1, ("Flock"));
        if (pfLock->fl_flags & FL_SLEEP) {
                cFYI(1, ("Blocking lock"));
 -               wait_flag = TRUE;
 +               wait_flag = true;
        }
        if (pfLock->fl_flags & FL_ACCESS)
                cFYI(1, ("Process suspended by mandatory locking - "
 @@ -792,7 +792,7 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
                                        stored_rc = CIFSSMBLock(xid, pTcon,
                                                        netfid,
                                                        li->length, li->offset,
 -                                                       1, 0, li->type, FALSE);
 +                                                       1, 0, li->type, false);
                                        if (stored_rc)
                                                rc = stored_rc;

@@ -864,7 +864,7 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
filemap_fdatawait from here so tell reopen_file not to flush data to server
now */
- rc = cifs_reopen_file(file, FALSE);

 +                               rc = cifs_reopen_file(file, false);
                                if (rc != 0)
                                        break;
                        }
 @@ -964,7 +964,7 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
                                   filemap_fdatawait from here so tell
                                   reopen_file not to flush data to
                                   server now */
 -                               rc = cifs_reopen_file(file, FALSE);
 +                               rc = cifs_reopen_file(file, false);
                                if (rc != 0)
                                        break;
                        }

@@ -1091,7 +1091,7 @@ refind_writable:

                        read_unlock(&GlobalSMBSeslock);
                        /* Had to unlock since following call can block */
 -                       rc = cifs_reopen_file(open_file->pfile, FALSE);
 +                       rc = cifs_reopen_file(open_file->pfile, false);
                        if (!rc) {
                                if (!open_file->closePend)
                                        return open_file;
 @@ -1606,7 +1606,7 @@ ssize_t cifs_user_read(struct file *file, char __user *read_data,
                        int buf_type = CIFS_NO_BUFFER;
                        if ((open_file->invalidHandle) &&
                            (!open_file->closePend)) {
 -                               rc = cifs_reopen_file(file, TRUE);
 +                               rc = cifs_reopen_file(file, true);
                                if (rc != 0)
                                        break;
                        }
 @@ -1691,7 +1691,7 @@ static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
                while (rc == -EAGAIN) {
                        if ((open_file->invalidHandle) &&
                            (!open_file->closePend)) {
 -                               rc = cifs_reopen_file(file, TRUE);
 +                               rc = cifs_reopen_file(file, true);
                                if (rc != 0)
                                        break;
                        }
 @@ -1848,7 +1848,7 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                while (rc == -EAGAIN) {
                        if ((open_file->invalidHandle) &&
                            (!open_file->closePend)) {
 -                               rc = cifs_reopen_file(file, TRUE);
 +                               rc = cifs_reopen_file(file, true);
                                if (rc != 0)
                                        break;
                        }

@@ -2007,10 +2007,10 @@ static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
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) +bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
{
if (!cifsInode)
- return 1;
+ return true;

        if (is_inode_writable(cifsInode)) {
                /* This inode is open for write at least once */
 @@ -2020,15 +2020,15 @@ int is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
                        /* since no page cache to corrupt on directio
                        we can change size safely */
 -                       return 1;
 +                       return true;
                }

                if (i_size_read(&cifsInode->vfs_inode) < end_of_file)

- return 1;
+ return true;

- return 0;

 +               return false;
        } else

- return 1;
+ return true;
}

static int cifs_prepare_write(struct file *file, struct page *page,
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index 13c728f..d247558 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -245,7 +245,7 @@ static int decode_sfu_inode(struct inode *inode, __u64 size,
struct cifs_sb_info *cifs_sb, int xid)

  {
        int rc;
 -       int oplock = FALSE;
 +       int oplock = 0;
        __u16 netfid;
        struct cifsTconInfo *pTcon = cifs_sb->tcon;
        char buf[24];
 @@ -353,7 +353,7 @@ int cifs_get_inode_info(struct inode **pinode,
        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
        char *tmp_path;
        char *buf = NULL;

- int adjustTZ = FALSE;
+ bool adjustTZ = false;

        pTcon = cifs_sb->tcon;
        cFYI(1, ("Getting info on %s", search_path));
 @@ -383,7 +383,7 @@ int cifs_get_inode_info(struct inode **pinode,
                        rc = SMBQueryInformation(xid, pTcon, search_path,
                                                 pfindData, cifs_sb->local_nls,
                                                 cifs_sb->mnt_cifs_flags);
 -                       adjustTZ = TRUE;
 +                       adjustTZ = true;
                }
        }
        /* dump_mem("\nQPathInfo return data",&findData, sizeof(findData)); */
 @@ -672,7 +672,7 @@ psx_del_no_retry:
        } else if (rc == -ENOENT) {
                d_drop(direntry);
        } else if (rc == -ETXTBSY) {

- int oplock = FALSE;
+ int oplock = 0;
__u16 netfid;

rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, DELETE,
@@ -702,7 +702,7 @@ psx_del_no_retry:

                                rc = -EOPNOTSUPP;

                        if (rc == -EOPNOTSUPP) {
 -                               int oplock = FALSE;
 +                               int oplock = 0;
                                __u16 netfid;
                        /*      rc = CIFSSMBSetAttrLegacy(xid, pTcon,
                                                          full_path,
 @@ -738,7 +738,7 @@ psx_del_no_retry:
                                if (direntry->d_inode)
                                        drop_nlink(direntry->d_inode);
                        } else if (rc == -ETXTBSY) {

- int oplock = FALSE;
+ int oplock = 0;
__u16 netfid;

rc = CIFSSMBOpen(xid, pTcon, full_path,
@@ -1103,7 +1103,7 @@ int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,

                cFYI(1, ("rename rc %d", rc));

        if ((rc == -EIO) || (rc == -EEXIST)) {
 -               int oplock = FALSE;
 +               int oplock = 0;
                __u16 netfid;

                /* BB FIXME Is Generic Read correct for rename? */
 @@ -1138,7 +1138,7 @@ int cifs_revalidate(struct dentry *direntry)
        struct cifsInodeInfo *cifsInode;
        loff_t local_size;
        struct timespec local_mtime;

- int invalidate_inode = FALSE;
+ bool invalidate_inode = false;

        if (direntry->d_inode == NULL)
                return -ENOENT;
 @@ -1220,7 +1220,7 @@ int cifs_revalidate(struct dentry *direntry)
                           only ones who could have modified the file and the
                           server copy is staler than ours */
                } else {
 -                       invalidate_inode = TRUE;
 +                       invalidate_inode = true;
                }
        }

@@ -1354,8 +1354,8 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)

        int rc = -EACCES;
        struct cifsFileInfo *open_file = NULL;
        FILE_BASIC_INFO time_buf;
 -       int set_time = FALSE;
 -       int set_dosattr = FALSE;
 +       bool set_time = false;
 +       bool set_dosattr = false;
        __u64 mode = 0xFFFFFFFFFFFFFFFFULL;
        __u64 uid = 0xFFFFFFFFFFFFFFFFULL;
        __u64 gid = 0xFFFFFFFFFFFFFFFFULL;
 @@ -1415,7 +1415,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                        __u16 nfid = open_file->netfid;
                        __u32 npid = open_file->pid;
                        rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size,
 -                                               nfid, npid, FALSE);
 +                                               nfid, npid, false);
                        atomic_dec(&open_file->wrtPending);
                        cFYI(1, ("SetFSize for attrs rc = %d", rc));
                        if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
 @@ -1435,13 +1435,13 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                           it was found or because there was an error setting
                           it by handle */
                        rc = CIFSSMBSetEOF(xid, pTcon, full_path,
 -                                          attrs->ia_size, FALSE,
 +                                          attrs->ia_size, false,
                                           cifs_sb->local_nls,
                                           cifs_sb->mnt_cifs_flags);
                        cFYI(1, ("SetEOF by path (setattrs) rc = %d", rc));
                        if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
                                __u16 netfid;

- int oplock = FALSE;
+ int oplock = 0;

rc = SMBLegacyOpen(xid, pTcon, full_path,
FILE_OPEN,
@@ -1465,7 +1465,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)

                /* Server is ok setting allocation size implicitly - no need
                   to call:
 -               CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size, TRUE,
 +               CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size, true,
                         cifs_sb->local_nls);
                   */

@@ -1512,7 +1512,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)

  #endif
                        /* not writeable */
                        if ((cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
 -                               set_dosattr = TRUE;
 +                               set_dosattr = true;
                                time_buf.Attributes =
                                        cpu_to_le32(cifsInode->cifsAttrs |
                                                    ATTR_READONLY);
 @@ -1522,7 +1522,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                        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;
 +                       set_dosattr = true;
                        time_buf.Attributes = cpu_to_le32(cifsInode->cifsAttrs &
                                            (~ATTR_READONLY));
                        /* Windows ignores set to zero */
 @@ -1536,14 +1536,14 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
        }

        if (attrs->ia_valid & ATTR_ATIME) {
 -               set_time = TRUE;
 +               set_time = true;
                time_buf.LastAccessTime =
                    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
        } else
                time_buf.LastAccessTime = 0;

        if (attrs->ia_valid & ATTR_MTIME) {
 -               set_time = TRUE;
 +               set_time = true;
                time_buf.LastWriteTime =
                    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
        } else

@@ -1554,7 +1554,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
server times */

if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
- set_time = TRUE;
+ set_time = true;
/* Although Samba throws this field away
it may be useful to Windows - but we do
not want to set ctime unless some other
@@ -1577,7 +1577,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)

                        rc = -EOPNOTSUPP;

                if (rc == -EOPNOTSUPP) {

- int oplock = FALSE;
+ int oplock = 0;
__u16 netfid;

cFYI(1, ("calling SetFileInfo since SetPathInfo for "
diff --git a/fs/cifs/link.c b/fs/cifs/link.c
index 4b5ca5f..98fa3bc 100644
--- a/fs/cifs/link.c
+++ b/fs/cifs/link.c
@@ -228,7 +228,7 @@ cifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen)

        struct inode *inode = direntry->d_inode;
        int rc = -EACCES;
        int xid;
 -       int oplock = FALSE;
 +       int oplock = 0;
        struct cifs_sb_info *cifs_sb;
        struct cifsTconInfo *pTcon;
        char *full_path = NULL;
 diff --git a/fs/cifs/misc.c b/fs/cifs/misc.c
 index cd9d977..a0b02d1 100644
 --- a/fs/cifs/misc.c
 +++ b/fs/cifs/misc.c
 @@ -496,7 +496,8 @@ checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
        }
        return 0;
  }
 -int
 +
 +bool
  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;
 @@ -522,17 +523,17 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
                                pnotify->Action));  /* BB removeme BB */
                        /*   cifs_dump_mem("Rcvd notify Data: ",buf,
                                sizeof(struct smb_hdr)+60); */
 -                       return TRUE;
 +                       return true;
                }
                if (pSMBr->hdr.Status.CifsError) {
                        cFYI(1, ("notify err 0x%d",
                                pSMBr->hdr.Status.CifsError));
 -                       return TRUE;
 +                       return true;
                }
 -               return FALSE;
 +               return false;
        }
        if (pSMB->hdr.Command != SMB_COM_LOCKING_ANDX)
 -               return FALSE;
 +               return false;
        if (pSMB->hdr.Flags & SMBFLG_RESPONSE) {
                /* no sense logging error on invalid handle on oplock
                   break - harmless race between close request and oplock
 @@ -541,21 +542,21 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
                if ((NT_STATUS_INVALID_HANDLE) ==
                   le32_to_cpu(pSMB->hdr.Status.CifsError)) {
                        cFYI(1, ("invalid handle on oplock break"));
 -                       return TRUE;
 +                       return true;
                } 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" */
 +                       return false; /* on valid oplock brk we get "request" */
                }
        }
        if (pSMB->hdr.WordCount != 8)

- return FALSE;
+ return false;

        cFYI(1, ("oplock type 0x%d level 0x%d",
                 pSMB->LockType, pSMB->OplockLevel));
        if (!(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE))

- return FALSE;
+ return false;

        /* look up tcon based on tid & uid */
        read_lock(&GlobalSMBSeslock);
 @@ -573,11 +574,11 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
                                            ("file id match, oplock break"));
                                        pCifsInode =
                                                CIFS_I(netfile->pInode);
 -                                       pCifsInode->clientCanCacheAll = FALSE;
 +                                       pCifsInode->clientCanCacheAll = false;
                                        if (pSMB->OplockLevel == 0)
                                                pCifsInode->clientCanCacheRead
 -                                                       = FALSE;
 -                                       pCifsInode->oplockPending = TRUE;
 +                                                       = false;
 +                                       pCifsInode->oplockPending = true;
                                        AllocOplockQEntry(netfile->pInode,
                                                          netfile->netfid,
                                                          tcon);
 @@ -585,17 +586,17 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
                                            ("about to wake up oplock thread"));
                                        if (oplockThread)
                                            wake_up_process(oplockThread);
 -                                       return TRUE;
 +                                       return true;
                                }
                        }
                        read_unlock(&GlobalSMBSeslock);
                        cFYI(1, ("No matching file for oplock break"));
 -                       return TRUE;
 +                       return true;
                }
        }
        read_unlock(&GlobalSMBSeslock);
        cFYI(1, ("Can not process oplock break for non-existent connection"));

- return TRUE;
+ return true;
}

void
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index 38811ce..06dda4b 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -447,8 +447,8 @@ static int initiate_cifs_search(const int xid, struct file *file)

        if (file->private_data == NULL)
                return -ENOMEM;
        cifsFile = file->private_data;
 -       cifsFile->invalidHandle = TRUE;
 -       cifsFile->srch_inf.endOfSearch = FALSE;
 +       cifsFile->invalidHandle = true;
 +       cifsFile->srch_inf.endOfSearch = false;
        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
        if (cifs_sb == NULL)
 @@ -484,7 +484,7 @@ ffirst_retry:
                           &cifsFile->netfid, &cifsFile->srch_inf,
                           cifs_sb->mnt_cifs_flags, CIFS_DIR_SEP(cifs_sb));
        if (rc == 0)
 -               cifsFile->invalidHandle = FALSE;
 +               cifsFile->invalidHandle = false;
        if ((rc == -EOPNOTSUPP) &&
                (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
                cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
 @@ -669,7 +669,7 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
           (index_to_find < first_entry_in_buffer)) {
                /* close and restart search */
                cFYI(1, ("search backing up - close and restart search"));
 -               cifsFile->invalidHandle = TRUE;
 +               cifsFile->invalidHandle = true;
                CIFSFindClose(xid, pTcon, cifsFile->netfid);
                kfree(cifsFile->search_resume_name);
                cifsFile->search_resume_name = NULL;
 @@ -691,7 +691,7 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
        }

        while ((index_to_find >= cifsFile->srch_inf.index_of_last_entry) &&
 -             (rc == 0) && (cifsFile->srch_inf.endOfSearch == FALSE)) {
 +             (rc == 0) && !cifsFile->srch_inf.endOfSearch) {
                cFYI(1, ("calling findnext2"));
                rc = CIFSFindNext(xid, pTcon, cifsFile->netfid,
                                  &cifsFile->srch_inf);
 @@ -1037,7 +1037,7 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
                                break;
                        }
                } /* else {
 -                       cifsFile->invalidHandle = TRUE;
 +                       cifsFile->invalidHandle = true;
                        CIFSFindClose(xid, pTcon, cifsFile->netfid);
                }
                kfree(cifsFile->search_resume_name);

diff --git a/fs/cifs/smbencrypt.c b/fs/cifs/smbencrypt.c index 58bbfd9..ff3232f 100644
--- a/fs/cifs/smbencrypt.c
+++ b/fs/cifs/smbencrypt.c
@@ -35,11 +35,11 @@
#include "cifs_debug.h"
#include "cifsencrypt.h"

-#ifndef FALSE
-#define FALSE 0
+#ifndef false
+#define false 0
#endif
-#ifndef TRUE
-#define TRUE 1
+#ifndef true
+#define true 1
#endif

/* following came from the other byteorder.h to avoid include conflicts */
diff --git a/fs/cifs/xattr.c b/fs/cifs/xattr.c
index 5122683..b48680c 100644
--- a/fs/cifs/xattr.c
+++ b/fs/cifs/xattr.c
@@ -262,7 +262,7 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,

  #ifdef CONFIG_CIFS_EXPERIMENTAL
                else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
                        __u16 fid;
 -                       int oplock = FALSE;
 +                       int oplock = 0;
                        struct cifs_ntsd *pacl = NULL;
                        __u32 buflen = 0;
                        if (experimEnabled)

--
1.5.4.rc2

Signature · 3 lines
Thanks,

Steve