Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit e6f9f8d0296aad7fbaf01de38ccaa1bf654bbda4

Authored by Al Viro
1 parent 63a44583f3
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

cifs: don't bother with ->i_dentry in ->destroy_inode() 

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

Showing 1 changed file with 0 additions and 1 deletions Inline Diff

1 /* 1 /*
2 * fs/cifs/cifsfs.c 2 * fs/cifs/cifsfs.c
3 * 3 *
4 * Copyright (C) International Business Machines Corp., 2002,2008 4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French (sfrench@us.ibm.com) 5 * Author(s): Steve French (sfrench@us.ibm.com)
6 * 6 *
7 * Common Internet FileSystem (CIFS) client 7 * Common Internet FileSystem (CIFS) client
8 * 8 *
9 * This library is free software; you can redistribute it and/or modify 9 * This library is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU Lesser General Public License as published 10 * it under the terms of the GNU Lesser General Public License as published
11 * by the Free Software Foundation; either version 2.1 of the License, or 11 * by the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version. 12 * (at your option) any later version.
13 * 13 *
14 * This library is distributed in the hope that it will be useful, 14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU Lesser General Public License for more details. 17 * the GNU Lesser General Public License for more details.
18 * 18 *
19 * You should have received a copy of the GNU Lesser General Public License 19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this library; if not, write to the Free Software 20 * along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */ 22 */
23 23
24 /* Note that BB means BUGBUG (ie something to fix eventually) */ 24 /* Note that BB means BUGBUG (ie something to fix eventually) */
25 25
26 #include <linux/module.h> 26 #include <linux/module.h>
27 #include <linux/fs.h> 27 #include <linux/fs.h>
28 #include <linux/mount.h> 28 #include <linux/mount.h>
29 #include <linux/slab.h> 29 #include <linux/slab.h>
30 #include <linux/init.h> 30 #include <linux/init.h>
31 #include <linux/list.h> 31 #include <linux/list.h>
32 #include <linux/seq_file.h> 32 #include <linux/seq_file.h>
33 #include <linux/vfs.h> 33 #include <linux/vfs.h>
34 #include <linux/mempool.h> 34 #include <linux/mempool.h>
35 #include <linux/delay.h> 35 #include <linux/delay.h>
36 #include <linux/kthread.h> 36 #include <linux/kthread.h>
37 #include <linux/freezer.h> 37 #include <linux/freezer.h>
38 #include <linux/namei.h> 38 #include <linux/namei.h>
39 #include <net/ipv6.h> 39 #include <net/ipv6.h>
40 #include "cifsfs.h" 40 #include "cifsfs.h"
41 #include "cifspdu.h" 41 #include "cifspdu.h"
42 #define DECLARE_GLOBALS_HERE 42 #define DECLARE_GLOBALS_HERE
43 #include "cifsglob.h" 43 #include "cifsglob.h"
44 #include "cifsproto.h" 44 #include "cifsproto.h"
45 #include "cifs_debug.h" 45 #include "cifs_debug.h"
46 #include "cifs_fs_sb.h" 46 #include "cifs_fs_sb.h"
47 #include <linux/mm.h> 47 #include <linux/mm.h>
48 #include <linux/key-type.h> 48 #include <linux/key-type.h>
49 #include "cifs_spnego.h" 49 #include "cifs_spnego.h"
50 #include "fscache.h" 50 #include "fscache.h"
51 #define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */ 51 #define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
52 52
53 int cifsFYI = 0; 53 int cifsFYI = 0;
54 int cifsERROR = 1; 54 int cifsERROR = 1;
55 int traceSMB = 0; 55 int traceSMB = 0;
56 bool enable_oplocks = true; 56 bool enable_oplocks = true;
57 unsigned int linuxExtEnabled = 1; 57 unsigned int linuxExtEnabled = 1;
58 unsigned int lookupCacheEnabled = 1; 58 unsigned int lookupCacheEnabled = 1;
59 unsigned int global_secflags = CIFSSEC_DEF; 59 unsigned int global_secflags = CIFSSEC_DEF;
60 /* unsigned int ntlmv2_support = 0; */ 60 /* unsigned int ntlmv2_support = 0; */
61 unsigned int sign_CIFS_PDUs = 1; 61 unsigned int sign_CIFS_PDUs = 1;
62 static const struct super_operations cifs_super_ops; 62 static const struct super_operations cifs_super_ops;
63 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE; 63 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
64 module_param(CIFSMaxBufSize, int, 0); 64 module_param(CIFSMaxBufSize, int, 0);
65 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). " 65 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
66 "Default: 16384 Range: 8192 to 130048"); 66 "Default: 16384 Range: 8192 to 130048");
67 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL; 67 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
68 module_param(cifs_min_rcv, int, 0); 68 module_param(cifs_min_rcv, int, 0);
69 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: " 69 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
70 "1 to 64"); 70 "1 to 64");
71 unsigned int cifs_min_small = 30; 71 unsigned int cifs_min_small = 30;
72 module_param(cifs_min_small, int, 0); 72 module_param(cifs_min_small, int, 0);
73 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 " 73 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
74 "Range: 2 to 256"); 74 "Range: 2 to 256");
75 unsigned int cifs_max_pending = CIFS_MAX_REQ; 75 unsigned int cifs_max_pending = CIFS_MAX_REQ;
76 module_param(cifs_max_pending, int, 0444); 76 module_param(cifs_max_pending, int, 0444);
77 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. " 77 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
78 "Default: 32767 Range: 2 to 32767."); 78 "Default: 32767 Range: 2 to 32767.");
79 module_param(enable_oplocks, bool, 0644); 79 module_param(enable_oplocks, bool, 0644);
80 MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks (bool). Default:" 80 MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks (bool). Default:"
81 "y/Y/1"); 81 "y/Y/1");
82 82
83 extern mempool_t *cifs_sm_req_poolp; 83 extern mempool_t *cifs_sm_req_poolp;
84 extern mempool_t *cifs_req_poolp; 84 extern mempool_t *cifs_req_poolp;
85 extern mempool_t *cifs_mid_poolp; 85 extern mempool_t *cifs_mid_poolp;
86 86
87 struct workqueue_struct *cifsiod_wq; 87 struct workqueue_struct *cifsiod_wq;
88 88
89 static int 89 static int
90 cifs_read_super(struct super_block *sb) 90 cifs_read_super(struct super_block *sb)
91 { 91 {
92 struct inode *inode; 92 struct inode *inode;
93 struct cifs_sb_info *cifs_sb; 93 struct cifs_sb_info *cifs_sb;
94 int rc = 0; 94 int rc = 0;
95 95
96 cifs_sb = CIFS_SB(sb); 96 cifs_sb = CIFS_SB(sb);
97 97
98 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL) 98 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
99 sb->s_flags |= MS_POSIXACL; 99 sb->s_flags |= MS_POSIXACL;
100 100
101 if (cifs_sb_master_tcon(cifs_sb)->ses->capabilities & CAP_LARGE_FILES) 101 if (cifs_sb_master_tcon(cifs_sb)->ses->capabilities & CAP_LARGE_FILES)
102 sb->s_maxbytes = MAX_LFS_FILESIZE; 102 sb->s_maxbytes = MAX_LFS_FILESIZE;
103 else 103 else
104 sb->s_maxbytes = MAX_NON_LFS; 104 sb->s_maxbytes = MAX_NON_LFS;
105 105
106 /* BB FIXME fix time_gran to be larger for LANMAN sessions */ 106 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
107 sb->s_time_gran = 100; 107 sb->s_time_gran = 100;
108 108
109 sb->s_magic = CIFS_MAGIC_NUMBER; 109 sb->s_magic = CIFS_MAGIC_NUMBER;
110 sb->s_op = &cifs_super_ops; 110 sb->s_op = &cifs_super_ops;
111 sb->s_bdi = &cifs_sb->bdi; 111 sb->s_bdi = &cifs_sb->bdi;
112 sb->s_blocksize = CIFS_MAX_MSGSIZE; 112 sb->s_blocksize = CIFS_MAX_MSGSIZE;
113 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */ 113 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
114 inode = cifs_root_iget(sb); 114 inode = cifs_root_iget(sb);
115 115
116 if (IS_ERR(inode)) { 116 if (IS_ERR(inode)) {
117 rc = PTR_ERR(inode); 117 rc = PTR_ERR(inode);
118 goto out_no_root; 118 goto out_no_root;
119 } 119 }
120 120
121 sb->s_root = d_make_root(inode); 121 sb->s_root = d_make_root(inode);
122 if (!sb->s_root) { 122 if (!sb->s_root) {
123 rc = -ENOMEM; 123 rc = -ENOMEM;
124 goto out_no_root; 124 goto out_no_root;
125 } 125 }
126 126
127 /* do that *after* d_make_root() - we want NULL ->d_op for root here */ 127 /* do that *after* d_make_root() - we want NULL ->d_op for root here */
128 if (cifs_sb_master_tcon(cifs_sb)->nocase) 128 if (cifs_sb_master_tcon(cifs_sb)->nocase)
129 sb->s_d_op = &cifs_ci_dentry_ops; 129 sb->s_d_op = &cifs_ci_dentry_ops;
130 else 130 else
131 sb->s_d_op = &cifs_dentry_ops; 131 sb->s_d_op = &cifs_dentry_ops;
132 132
133 #ifdef CONFIG_CIFS_NFSD_EXPORT 133 #ifdef CONFIG_CIFS_NFSD_EXPORT
134 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) { 134 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
135 cFYI(1, "export ops supported"); 135 cFYI(1, "export ops supported");
136 sb->s_export_op = &cifs_export_ops; 136 sb->s_export_op = &cifs_export_ops;
137 } 137 }
138 #endif /* CONFIG_CIFS_NFSD_EXPORT */ 138 #endif /* CONFIG_CIFS_NFSD_EXPORT */
139 139
140 return 0; 140 return 0;
141 141
142 out_no_root: 142 out_no_root:
143 cERROR(1, "cifs_read_super: get root inode failed"); 143 cERROR(1, "cifs_read_super: get root inode failed");
144 return rc; 144 return rc;
145 } 145 }
146 146
147 static void cifs_kill_sb(struct super_block *sb) 147 static void cifs_kill_sb(struct super_block *sb)
148 { 148 {
149 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 149 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
150 kill_anon_super(sb); 150 kill_anon_super(sb);
151 cifs_umount(cifs_sb); 151 cifs_umount(cifs_sb);
152 } 152 }
153 153
154 static int 154 static int
155 cifs_statfs(struct dentry *dentry, struct kstatfs *buf) 155 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
156 { 156 {
157 struct super_block *sb = dentry->d_sb; 157 struct super_block *sb = dentry->d_sb;
158 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 158 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
159 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 159 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
160 int rc = -EOPNOTSUPP; 160 int rc = -EOPNOTSUPP;
161 int xid; 161 int xid;
162 162
163 xid = GetXid(); 163 xid = GetXid();
164 164
165 buf->f_type = CIFS_MAGIC_NUMBER; 165 buf->f_type = CIFS_MAGIC_NUMBER;
166 166
167 /* 167 /*
168 * PATH_MAX may be too long - it would presumably be total path, 168 * PATH_MAX may be too long - it would presumably be total path,
169 * but note that some servers (includinng Samba 3) have a shorter 169 * but note that some servers (includinng Samba 3) have a shorter
170 * maximum path. 170 * maximum path.
171 * 171 *
172 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO. 172 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
173 */ 173 */
174 buf->f_namelen = PATH_MAX; 174 buf->f_namelen = PATH_MAX;
175 buf->f_files = 0; /* undefined */ 175 buf->f_files = 0; /* undefined */
176 buf->f_ffree = 0; /* unlimited */ 176 buf->f_ffree = 0; /* unlimited */
177 177
178 /* 178 /*
179 * We could add a second check for a QFS Unix capability bit 179 * We could add a second check for a QFS Unix capability bit
180 */ 180 */
181 if ((tcon->ses->capabilities & CAP_UNIX) && 181 if ((tcon->ses->capabilities & CAP_UNIX) &&
182 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability))) 182 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
183 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf); 183 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
184 184
185 /* 185 /*
186 * Only need to call the old QFSInfo if failed on newer one, 186 * Only need to call the old QFSInfo if failed on newer one,
187 * e.g. by OS/2. 187 * e.g. by OS/2.
188 **/ 188 **/
189 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS)) 189 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
190 rc = CIFSSMBQFSInfo(xid, tcon, buf); 190 rc = CIFSSMBQFSInfo(xid, tcon, buf);
191 191
192 /* 192 /*
193 * Some old Windows servers also do not support level 103, retry with 193 * Some old Windows servers also do not support level 103, retry with
194 * older level one if old server failed the previous call or we 194 * older level one if old server failed the previous call or we
195 * bypassed it because we detected that this was an older LANMAN sess 195 * bypassed it because we detected that this was an older LANMAN sess
196 */ 196 */
197 if (rc) 197 if (rc)
198 rc = SMBOldQFSInfo(xid, tcon, buf); 198 rc = SMBOldQFSInfo(xid, tcon, buf);
199 199
200 FreeXid(xid); 200 FreeXid(xid);
201 return 0; 201 return 0;
202 } 202 }
203 203
204 static int cifs_permission(struct inode *inode, int mask) 204 static int cifs_permission(struct inode *inode, int mask)
205 { 205 {
206 struct cifs_sb_info *cifs_sb; 206 struct cifs_sb_info *cifs_sb;
207 207
208 cifs_sb = CIFS_SB(inode->i_sb); 208 cifs_sb = CIFS_SB(inode->i_sb);
209 209
210 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) { 210 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
211 if ((mask & MAY_EXEC) && !execute_ok(inode)) 211 if ((mask & MAY_EXEC) && !execute_ok(inode))
212 return -EACCES; 212 return -EACCES;
213 else 213 else
214 return 0; 214 return 0;
215 } else /* file mode might have been restricted at mount time 215 } else /* file mode might have been restricted at mount time
216 on the client (above and beyond ACL on servers) for 216 on the client (above and beyond ACL on servers) for
217 servers which do not support setting and viewing mode bits, 217 servers which do not support setting and viewing mode bits,
218 so allowing client to check permissions is useful */ 218 so allowing client to check permissions is useful */
219 return generic_permission(inode, mask); 219 return generic_permission(inode, mask);
220 } 220 }
221 221
222 static struct kmem_cache *cifs_inode_cachep; 222 static struct kmem_cache *cifs_inode_cachep;
223 static struct kmem_cache *cifs_req_cachep; 223 static struct kmem_cache *cifs_req_cachep;
224 static struct kmem_cache *cifs_mid_cachep; 224 static struct kmem_cache *cifs_mid_cachep;
225 static struct kmem_cache *cifs_sm_req_cachep; 225 static struct kmem_cache *cifs_sm_req_cachep;
226 mempool_t *cifs_sm_req_poolp; 226 mempool_t *cifs_sm_req_poolp;
227 mempool_t *cifs_req_poolp; 227 mempool_t *cifs_req_poolp;
228 mempool_t *cifs_mid_poolp; 228 mempool_t *cifs_mid_poolp;
229 229
230 static struct inode * 230 static struct inode *
231 cifs_alloc_inode(struct super_block *sb) 231 cifs_alloc_inode(struct super_block *sb)
232 { 232 {
233 struct cifsInodeInfo *cifs_inode; 233 struct cifsInodeInfo *cifs_inode;
234 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL); 234 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
235 if (!cifs_inode) 235 if (!cifs_inode)
236 return NULL; 236 return NULL;
237 cifs_inode->cifsAttrs = 0x20; /* default */ 237 cifs_inode->cifsAttrs = 0x20; /* default */
238 cifs_inode->time = 0; 238 cifs_inode->time = 0;
239 /* Until the file is open and we have gotten oplock 239 /* Until the file is open and we have gotten oplock
240 info back from the server, can not assume caching of 240 info back from the server, can not assume caching of
241 file data or metadata */ 241 file data or metadata */
242 cifs_set_oplock_level(cifs_inode, 0); 242 cifs_set_oplock_level(cifs_inode, 0);
243 cifs_inode->delete_pending = false; 243 cifs_inode->delete_pending = false;
244 cifs_inode->invalid_mapping = false; 244 cifs_inode->invalid_mapping = false;
245 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */ 245 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
246 cifs_inode->server_eof = 0; 246 cifs_inode->server_eof = 0;
247 cifs_inode->uniqueid = 0; 247 cifs_inode->uniqueid = 0;
248 cifs_inode->createtime = 0; 248 cifs_inode->createtime = 0;
249 249
250 /* Can not set i_flags here - they get immediately overwritten 250 /* Can not set i_flags here - they get immediately overwritten
251 to zero by the VFS */ 251 to zero by the VFS */
252 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/ 252 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
253 INIT_LIST_HEAD(&cifs_inode->openFileList); 253 INIT_LIST_HEAD(&cifs_inode->openFileList);
254 return &cifs_inode->vfs_inode; 254 return &cifs_inode->vfs_inode;
255 } 255 }
256 256
257 static void cifs_i_callback(struct rcu_head *head) 257 static void cifs_i_callback(struct rcu_head *head)
258 { 258 {
259 struct inode *inode = container_of(head, struct inode, i_rcu); 259 struct inode *inode = container_of(head, struct inode, i_rcu);
260 INIT_LIST_HEAD(&inode->i_dentry);
261 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode)); 260 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
262 } 261 }
263 262
264 static void 263 static void
265 cifs_destroy_inode(struct inode *inode) 264 cifs_destroy_inode(struct inode *inode)
266 { 265 {
267 call_rcu(&inode->i_rcu, cifs_i_callback); 266 call_rcu(&inode->i_rcu, cifs_i_callback);
268 } 267 }
269 268
270 static void 269 static void
271 cifs_evict_inode(struct inode *inode) 270 cifs_evict_inode(struct inode *inode)
272 { 271 {
273 truncate_inode_pages(&inode->i_data, 0); 272 truncate_inode_pages(&inode->i_data, 0);
274 clear_inode(inode); 273 clear_inode(inode);
275 cifs_fscache_release_inode_cookie(inode); 274 cifs_fscache_release_inode_cookie(inode);
276 } 275 }
277 276
278 static void 277 static void
279 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server) 278 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
280 { 279 {
281 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr; 280 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
282 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr; 281 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
283 282
284 seq_printf(s, ",addr="); 283 seq_printf(s, ",addr=");
285 284
286 switch (server->dstaddr.ss_family) { 285 switch (server->dstaddr.ss_family) {
287 case AF_INET: 286 case AF_INET:
288 seq_printf(s, "%pI4", &sa->sin_addr.s_addr); 287 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
289 break; 288 break;
290 case AF_INET6: 289 case AF_INET6:
291 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr); 290 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
292 if (sa6->sin6_scope_id) 291 if (sa6->sin6_scope_id)
293 seq_printf(s, "%%%u", sa6->sin6_scope_id); 292 seq_printf(s, "%%%u", sa6->sin6_scope_id);
294 break; 293 break;
295 default: 294 default:
296 seq_printf(s, "(unknown)"); 295 seq_printf(s, "(unknown)");
297 } 296 }
298 } 297 }
299 298
300 static void 299 static void
301 cifs_show_security(struct seq_file *s, struct TCP_Server_Info *server) 300 cifs_show_security(struct seq_file *s, struct TCP_Server_Info *server)
302 { 301 {
303 seq_printf(s, ",sec="); 302 seq_printf(s, ",sec=");
304 303
305 switch (server->secType) { 304 switch (server->secType) {
306 case LANMAN: 305 case LANMAN:
307 seq_printf(s, "lanman"); 306 seq_printf(s, "lanman");
308 break; 307 break;
309 case NTLMv2: 308 case NTLMv2:
310 seq_printf(s, "ntlmv2"); 309 seq_printf(s, "ntlmv2");
311 break; 310 break;
312 case NTLM: 311 case NTLM:
313 seq_printf(s, "ntlm"); 312 seq_printf(s, "ntlm");
314 break; 313 break;
315 case Kerberos: 314 case Kerberos:
316 seq_printf(s, "krb5"); 315 seq_printf(s, "krb5");
317 break; 316 break;
318 case RawNTLMSSP: 317 case RawNTLMSSP:
319 seq_printf(s, "ntlmssp"); 318 seq_printf(s, "ntlmssp");
320 break; 319 break;
321 default: 320 default:
322 /* shouldn't ever happen */ 321 /* shouldn't ever happen */
323 seq_printf(s, "unknown"); 322 seq_printf(s, "unknown");
324 break; 323 break;
325 } 324 }
326 325
327 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) 326 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
328 seq_printf(s, "i"); 327 seq_printf(s, "i");
329 } 328 }
330 329
331 static void 330 static void
332 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb) 331 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
333 { 332 {
334 seq_printf(s, ",cache="); 333 seq_printf(s, ",cache=");
335 334
336 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) 335 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
337 seq_printf(s, "strict"); 336 seq_printf(s, "strict");
338 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) 337 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
339 seq_printf(s, "none"); 338 seq_printf(s, "none");
340 else 339 else
341 seq_printf(s, "loose"); 340 seq_printf(s, "loose");
342 } 341 }
343 342
344 /* 343 /*
345 * cifs_show_options() is for displaying mount options in /proc/mounts. 344 * cifs_show_options() is for displaying mount options in /proc/mounts.
346 * Not all settable options are displayed but most of the important 345 * Not all settable options are displayed but most of the important
347 * ones are. 346 * ones are.
348 */ 347 */
349 static int 348 static int
350 cifs_show_options(struct seq_file *s, struct dentry *root) 349 cifs_show_options(struct seq_file *s, struct dentry *root)
351 { 350 {
352 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb); 351 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
353 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 352 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
354 struct sockaddr *srcaddr; 353 struct sockaddr *srcaddr;
355 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr; 354 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
356 355
357 seq_printf(s, ",vers=%s", tcon->ses->server->vals->version_string); 356 seq_printf(s, ",vers=%s", tcon->ses->server->vals->version_string);
358 cifs_show_security(s, tcon->ses->server); 357 cifs_show_security(s, tcon->ses->server);
359 cifs_show_cache_flavor(s, cifs_sb); 358 cifs_show_cache_flavor(s, cifs_sb);
360 359
361 seq_printf(s, ",unc=%s", tcon->treeName); 360 seq_printf(s, ",unc=%s", tcon->treeName);
362 361
363 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) 362 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
364 seq_printf(s, ",multiuser"); 363 seq_printf(s, ",multiuser");
365 else if (tcon->ses->user_name) 364 else if (tcon->ses->user_name)
366 seq_printf(s, ",username=%s", tcon->ses->user_name); 365 seq_printf(s, ",username=%s", tcon->ses->user_name);
367 366
368 if (tcon->ses->domainName) 367 if (tcon->ses->domainName)
369 seq_printf(s, ",domain=%s", tcon->ses->domainName); 368 seq_printf(s, ",domain=%s", tcon->ses->domainName);
370 369
371 if (srcaddr->sa_family != AF_UNSPEC) { 370 if (srcaddr->sa_family != AF_UNSPEC) {
372 struct sockaddr_in *saddr4; 371 struct sockaddr_in *saddr4;
373 struct sockaddr_in6 *saddr6; 372 struct sockaddr_in6 *saddr6;
374 saddr4 = (struct sockaddr_in *)srcaddr; 373 saddr4 = (struct sockaddr_in *)srcaddr;
375 saddr6 = (struct sockaddr_in6 *)srcaddr; 374 saddr6 = (struct sockaddr_in6 *)srcaddr;
376 if (srcaddr->sa_family == AF_INET6) 375 if (srcaddr->sa_family == AF_INET6)
377 seq_printf(s, ",srcaddr=%pI6c", 376 seq_printf(s, ",srcaddr=%pI6c",
378 &saddr6->sin6_addr); 377 &saddr6->sin6_addr);
379 else if (srcaddr->sa_family == AF_INET) 378 else if (srcaddr->sa_family == AF_INET)
380 seq_printf(s, ",srcaddr=%pI4", 379 seq_printf(s, ",srcaddr=%pI4",
381 &saddr4->sin_addr.s_addr); 380 &saddr4->sin_addr.s_addr);
382 else 381 else
383 seq_printf(s, ",srcaddr=BAD-AF:%i", 382 seq_printf(s, ",srcaddr=BAD-AF:%i",
384 (int)(srcaddr->sa_family)); 383 (int)(srcaddr->sa_family));
385 } 384 }
386 385
387 seq_printf(s, ",uid=%u", cifs_sb->mnt_uid); 386 seq_printf(s, ",uid=%u", cifs_sb->mnt_uid);
388 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) 387 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
389 seq_printf(s, ",forceuid"); 388 seq_printf(s, ",forceuid");
390 else 389 else
391 seq_printf(s, ",noforceuid"); 390 seq_printf(s, ",noforceuid");
392 391
393 seq_printf(s, ",gid=%u", cifs_sb->mnt_gid); 392 seq_printf(s, ",gid=%u", cifs_sb->mnt_gid);
394 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) 393 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
395 seq_printf(s, ",forcegid"); 394 seq_printf(s, ",forcegid");
396 else 395 else
397 seq_printf(s, ",noforcegid"); 396 seq_printf(s, ",noforcegid");
398 397
399 cifs_show_address(s, tcon->ses->server); 398 cifs_show_address(s, tcon->ses->server);
400 399
401 if (!tcon->unix_ext) 400 if (!tcon->unix_ext)
402 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho", 401 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
403 cifs_sb->mnt_file_mode, 402 cifs_sb->mnt_file_mode,
404 cifs_sb->mnt_dir_mode); 403 cifs_sb->mnt_dir_mode);
405 if (tcon->seal) 404 if (tcon->seal)
406 seq_printf(s, ",seal"); 405 seq_printf(s, ",seal");
407 if (tcon->nocase) 406 if (tcon->nocase)
408 seq_printf(s, ",nocase"); 407 seq_printf(s, ",nocase");
409 if (tcon->retry) 408 if (tcon->retry)
410 seq_printf(s, ",hard"); 409 seq_printf(s, ",hard");
411 if (tcon->unix_ext) 410 if (tcon->unix_ext)
412 seq_printf(s, ",unix"); 411 seq_printf(s, ",unix");
413 else 412 else
414 seq_printf(s, ",nounix"); 413 seq_printf(s, ",nounix");
415 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) 414 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
416 seq_printf(s, ",posixpaths"); 415 seq_printf(s, ",posixpaths");
417 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) 416 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
418 seq_printf(s, ",setuids"); 417 seq_printf(s, ",setuids");
419 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) 418 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
420 seq_printf(s, ",serverino"); 419 seq_printf(s, ",serverino");
421 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD) 420 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
422 seq_printf(s, ",rwpidforward"); 421 seq_printf(s, ",rwpidforward");
423 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) 422 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
424 seq_printf(s, ",forcemand"); 423 seq_printf(s, ",forcemand");
425 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) 424 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
426 seq_printf(s, ",nouser_xattr"); 425 seq_printf(s, ",nouser_xattr");
427 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR) 426 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
428 seq_printf(s, ",mapchars"); 427 seq_printf(s, ",mapchars");
429 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) 428 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
430 seq_printf(s, ",sfu"); 429 seq_printf(s, ",sfu");
431 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL) 430 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
432 seq_printf(s, ",nobrl"); 431 seq_printf(s, ",nobrl");
433 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) 432 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
434 seq_printf(s, ",cifsacl"); 433 seq_printf(s, ",cifsacl");
435 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) 434 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
436 seq_printf(s, ",dynperm"); 435 seq_printf(s, ",dynperm");
437 if (root->d_sb->s_flags & MS_POSIXACL) 436 if (root->d_sb->s_flags & MS_POSIXACL)
438 seq_printf(s, ",acl"); 437 seq_printf(s, ",acl");
439 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) 438 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
440 seq_printf(s, ",mfsymlinks"); 439 seq_printf(s, ",mfsymlinks");
441 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE) 440 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
442 seq_printf(s, ",fsc"); 441 seq_printf(s, ",fsc");
443 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC) 442 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
444 seq_printf(s, ",nostrictsync"); 443 seq_printf(s, ",nostrictsync");
445 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) 444 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
446 seq_printf(s, ",noperm"); 445 seq_printf(s, ",noperm");
447 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID) 446 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
448 seq_printf(s, ",backupuid=%u", cifs_sb->mnt_backupuid); 447 seq_printf(s, ",backupuid=%u", cifs_sb->mnt_backupuid);
449 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID) 448 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
450 seq_printf(s, ",backupgid=%u", cifs_sb->mnt_backupgid); 449 seq_printf(s, ",backupgid=%u", cifs_sb->mnt_backupgid);
451 450
452 seq_printf(s, ",rsize=%u", cifs_sb->rsize); 451 seq_printf(s, ",rsize=%u", cifs_sb->rsize);
453 seq_printf(s, ",wsize=%u", cifs_sb->wsize); 452 seq_printf(s, ",wsize=%u", cifs_sb->wsize);
454 /* convert actimeo and display it in seconds */ 453 /* convert actimeo and display it in seconds */
455 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ); 454 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
456 455
457 return 0; 456 return 0;
458 } 457 }
459 458
460 static void cifs_umount_begin(struct super_block *sb) 459 static void cifs_umount_begin(struct super_block *sb)
461 { 460 {
462 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 461 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
463 struct cifs_tcon *tcon; 462 struct cifs_tcon *tcon;
464 463
465 if (cifs_sb == NULL) 464 if (cifs_sb == NULL)
466 return; 465 return;
467 466
468 tcon = cifs_sb_master_tcon(cifs_sb); 467 tcon = cifs_sb_master_tcon(cifs_sb);
469 468
470 spin_lock(&cifs_tcp_ses_lock); 469 spin_lock(&cifs_tcp_ses_lock);
471 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) { 470 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
472 /* we have other mounts to same share or we have 471 /* we have other mounts to same share or we have
473 already tried to force umount this and woken up 472 already tried to force umount this and woken up
474 all waiting network requests, nothing to do */ 473 all waiting network requests, nothing to do */
475 spin_unlock(&cifs_tcp_ses_lock); 474 spin_unlock(&cifs_tcp_ses_lock);
476 return; 475 return;
477 } else if (tcon->tc_count == 1) 476 } else if (tcon->tc_count == 1)
478 tcon->tidStatus = CifsExiting; 477 tcon->tidStatus = CifsExiting;
479 spin_unlock(&cifs_tcp_ses_lock); 478 spin_unlock(&cifs_tcp_ses_lock);
480 479
481 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */ 480 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
482 /* cancel_notify_requests(tcon); */ 481 /* cancel_notify_requests(tcon); */
483 if (tcon->ses && tcon->ses->server) { 482 if (tcon->ses && tcon->ses->server) {
484 cFYI(1, "wake up tasks now - umount begin not complete"); 483 cFYI(1, "wake up tasks now - umount begin not complete");
485 wake_up_all(&tcon->ses->server->request_q); 484 wake_up_all(&tcon->ses->server->request_q);
486 wake_up_all(&tcon->ses->server->response_q); 485 wake_up_all(&tcon->ses->server->response_q);
487 msleep(1); /* yield */ 486 msleep(1); /* yield */
488 /* we have to kick the requests once more */ 487 /* we have to kick the requests once more */
489 wake_up_all(&tcon->ses->server->response_q); 488 wake_up_all(&tcon->ses->server->response_q);
490 msleep(1); 489 msleep(1);
491 } 490 }
492 491
493 return; 492 return;
494 } 493 }
495 494
496 #ifdef CONFIG_CIFS_STATS2 495 #ifdef CONFIG_CIFS_STATS2
497 static int cifs_show_stats(struct seq_file *s, struct dentry *root) 496 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
498 { 497 {
499 /* BB FIXME */ 498 /* BB FIXME */
500 return 0; 499 return 0;
501 } 500 }
502 #endif 501 #endif
503 502
504 static int cifs_remount(struct super_block *sb, int *flags, char *data) 503 static int cifs_remount(struct super_block *sb, int *flags, char *data)
505 { 504 {
506 *flags |= MS_NODIRATIME; 505 *flags |= MS_NODIRATIME;
507 return 0; 506 return 0;
508 } 507 }
509 508
510 static int cifs_drop_inode(struct inode *inode) 509 static int cifs_drop_inode(struct inode *inode)
511 { 510 {
512 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 511 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
513 512
514 /* no serverino => unconditional eviction */ 513 /* no serverino => unconditional eviction */
515 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) || 514 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
516 generic_drop_inode(inode); 515 generic_drop_inode(inode);
517 } 516 }
518 517
519 static const struct super_operations cifs_super_ops = { 518 static const struct super_operations cifs_super_ops = {
520 .statfs = cifs_statfs, 519 .statfs = cifs_statfs,
521 .alloc_inode = cifs_alloc_inode, 520 .alloc_inode = cifs_alloc_inode,
522 .destroy_inode = cifs_destroy_inode, 521 .destroy_inode = cifs_destroy_inode,
523 .drop_inode = cifs_drop_inode, 522 .drop_inode = cifs_drop_inode,
524 .evict_inode = cifs_evict_inode, 523 .evict_inode = cifs_evict_inode,
525 /* .delete_inode = cifs_delete_inode, */ /* Do not need above 524 /* .delete_inode = cifs_delete_inode, */ /* Do not need above
526 function unless later we add lazy close of inodes or unless the 525 function unless later we add lazy close of inodes or unless the
527 kernel forgets to call us with the same number of releases (closes) 526 kernel forgets to call us with the same number of releases (closes)
528 as opens */ 527 as opens */
529 .show_options = cifs_show_options, 528 .show_options = cifs_show_options,
530 .umount_begin = cifs_umount_begin, 529 .umount_begin = cifs_umount_begin,
531 .remount_fs = cifs_remount, 530 .remount_fs = cifs_remount,
532 #ifdef CONFIG_CIFS_STATS2 531 #ifdef CONFIG_CIFS_STATS2
533 .show_stats = cifs_show_stats, 532 .show_stats = cifs_show_stats,
534 #endif 533 #endif
535 }; 534 };
536 535
537 /* 536 /*
538 * Get root dentry from superblock according to prefix path mount option. 537 * Get root dentry from superblock according to prefix path mount option.
539 * Return dentry with refcount + 1 on success and NULL otherwise. 538 * Return dentry with refcount + 1 on success and NULL otherwise.
540 */ 539 */
541 static struct dentry * 540 static struct dentry *
542 cifs_get_root(struct smb_vol *vol, struct super_block *sb) 541 cifs_get_root(struct smb_vol *vol, struct super_block *sb)
543 { 542 {
544 struct dentry *dentry; 543 struct dentry *dentry;
545 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 544 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
546 char *full_path = NULL; 545 char *full_path = NULL;
547 char *s, *p; 546 char *s, *p;
548 char sep; 547 char sep;
549 548
550 full_path = cifs_build_path_to_root(vol, cifs_sb, 549 full_path = cifs_build_path_to_root(vol, cifs_sb,
551 cifs_sb_master_tcon(cifs_sb)); 550 cifs_sb_master_tcon(cifs_sb));
552 if (full_path == NULL) 551 if (full_path == NULL)
553 return ERR_PTR(-ENOMEM); 552 return ERR_PTR(-ENOMEM);
554 553
555 cFYI(1, "Get root dentry for %s", full_path); 554 cFYI(1, "Get root dentry for %s", full_path);
556 555
557 sep = CIFS_DIR_SEP(cifs_sb); 556 sep = CIFS_DIR_SEP(cifs_sb);
558 dentry = dget(sb->s_root); 557 dentry = dget(sb->s_root);
559 p = s = full_path; 558 p = s = full_path;
560 559
561 do { 560 do {
562 struct inode *dir = dentry->d_inode; 561 struct inode *dir = dentry->d_inode;
563 struct dentry *child; 562 struct dentry *child;
564 563
565 if (!dir) { 564 if (!dir) {
566 dput(dentry); 565 dput(dentry);
567 dentry = ERR_PTR(-ENOENT); 566 dentry = ERR_PTR(-ENOENT);
568 break; 567 break;
569 } 568 }
570 569
571 /* skip separators */ 570 /* skip separators */
572 while (*s == sep) 571 while (*s == sep)
573 s++; 572 s++;
574 if (!*s) 573 if (!*s)
575 break; 574 break;
576 p = s++; 575 p = s++;
577 /* next separator */ 576 /* next separator */
578 while (*s && *s != sep) 577 while (*s && *s != sep)
579 s++; 578 s++;
580 579
581 mutex_lock(&dir->i_mutex); 580 mutex_lock(&dir->i_mutex);
582 child = lookup_one_len(p, dentry, s - p); 581 child = lookup_one_len(p, dentry, s - p);
583 mutex_unlock(&dir->i_mutex); 582 mutex_unlock(&dir->i_mutex);
584 dput(dentry); 583 dput(dentry);
585 dentry = child; 584 dentry = child;
586 } while (!IS_ERR(dentry)); 585 } while (!IS_ERR(dentry));
587 kfree(full_path); 586 kfree(full_path);
588 return dentry; 587 return dentry;
589 } 588 }
590 589
591 static int cifs_set_super(struct super_block *sb, void *data) 590 static int cifs_set_super(struct super_block *sb, void *data)
592 { 591 {
593 struct cifs_mnt_data *mnt_data = data; 592 struct cifs_mnt_data *mnt_data = data;
594 sb->s_fs_info = mnt_data->cifs_sb; 593 sb->s_fs_info = mnt_data->cifs_sb;
595 return set_anon_super(sb, NULL); 594 return set_anon_super(sb, NULL);
596 } 595 }
597 596
598 static struct dentry * 597 static struct dentry *
599 cifs_do_mount(struct file_system_type *fs_type, 598 cifs_do_mount(struct file_system_type *fs_type,
600 int flags, const char *dev_name, void *data) 599 int flags, const char *dev_name, void *data)
601 { 600 {
602 int rc; 601 int rc;
603 struct super_block *sb; 602 struct super_block *sb;
604 struct cifs_sb_info *cifs_sb; 603 struct cifs_sb_info *cifs_sb;
605 struct smb_vol *volume_info; 604 struct smb_vol *volume_info;
606 struct cifs_mnt_data mnt_data; 605 struct cifs_mnt_data mnt_data;
607 struct dentry *root; 606 struct dentry *root;
608 607
609 cFYI(1, "Devname: %s flags: %d ", dev_name, flags); 608 cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
610 609
611 volume_info = cifs_get_volume_info((char *)data, dev_name); 610 volume_info = cifs_get_volume_info((char *)data, dev_name);
612 if (IS_ERR(volume_info)) 611 if (IS_ERR(volume_info))
613 return ERR_CAST(volume_info); 612 return ERR_CAST(volume_info);
614 613
615 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL); 614 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
616 if (cifs_sb == NULL) { 615 if (cifs_sb == NULL) {
617 root = ERR_PTR(-ENOMEM); 616 root = ERR_PTR(-ENOMEM);
618 goto out_nls; 617 goto out_nls;
619 } 618 }
620 619
621 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL); 620 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
622 if (cifs_sb->mountdata == NULL) { 621 if (cifs_sb->mountdata == NULL) {
623 root = ERR_PTR(-ENOMEM); 622 root = ERR_PTR(-ENOMEM);
624 goto out_cifs_sb; 623 goto out_cifs_sb;
625 } 624 }
626 625
627 cifs_setup_cifs_sb(volume_info, cifs_sb); 626 cifs_setup_cifs_sb(volume_info, cifs_sb);
628 627
629 rc = cifs_mount(cifs_sb, volume_info); 628 rc = cifs_mount(cifs_sb, volume_info);
630 if (rc) { 629 if (rc) {
631 if (!(flags & MS_SILENT)) 630 if (!(flags & MS_SILENT))
632 cERROR(1, "cifs_mount failed w/return code = %d", rc); 631 cERROR(1, "cifs_mount failed w/return code = %d", rc);
633 root = ERR_PTR(rc); 632 root = ERR_PTR(rc);
634 goto out_mountdata; 633 goto out_mountdata;
635 } 634 }
636 635
637 mnt_data.vol = volume_info; 636 mnt_data.vol = volume_info;
638 mnt_data.cifs_sb = cifs_sb; 637 mnt_data.cifs_sb = cifs_sb;
639 mnt_data.flags = flags; 638 mnt_data.flags = flags;
640 639
641 sb = sget(fs_type, cifs_match_super, cifs_set_super, &mnt_data); 640 sb = sget(fs_type, cifs_match_super, cifs_set_super, &mnt_data);
642 if (IS_ERR(sb)) { 641 if (IS_ERR(sb)) {
643 root = ERR_CAST(sb); 642 root = ERR_CAST(sb);
644 cifs_umount(cifs_sb); 643 cifs_umount(cifs_sb);
645 goto out; 644 goto out;
646 } 645 }
647 646
648 if (sb->s_root) { 647 if (sb->s_root) {
649 cFYI(1, "Use existing superblock"); 648 cFYI(1, "Use existing superblock");
650 cifs_umount(cifs_sb); 649 cifs_umount(cifs_sb);
651 } else { 650 } else {
652 sb->s_flags = flags; 651 sb->s_flags = flags;
653 /* BB should we make this contingent on mount parm? */ 652 /* BB should we make this contingent on mount parm? */
654 sb->s_flags |= MS_NODIRATIME | MS_NOATIME; 653 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
655 654
656 rc = cifs_read_super(sb); 655 rc = cifs_read_super(sb);
657 if (rc) { 656 if (rc) {
658 root = ERR_PTR(rc); 657 root = ERR_PTR(rc);
659 goto out_super; 658 goto out_super;
660 } 659 }
661 660
662 sb->s_flags |= MS_ACTIVE; 661 sb->s_flags |= MS_ACTIVE;
663 } 662 }
664 663
665 root = cifs_get_root(volume_info, sb); 664 root = cifs_get_root(volume_info, sb);
666 if (IS_ERR(root)) 665 if (IS_ERR(root))
667 goto out_super; 666 goto out_super;
668 667
669 cFYI(1, "dentry root is: %p", root); 668 cFYI(1, "dentry root is: %p", root);
670 goto out; 669 goto out;
671 670
672 out_super: 671 out_super:
673 deactivate_locked_super(sb); 672 deactivate_locked_super(sb);
674 out: 673 out:
675 cifs_cleanup_volume_info(volume_info); 674 cifs_cleanup_volume_info(volume_info);
676 return root; 675 return root;
677 676
678 out_mountdata: 677 out_mountdata:
679 kfree(cifs_sb->mountdata); 678 kfree(cifs_sb->mountdata);
680 out_cifs_sb: 679 out_cifs_sb:
681 kfree(cifs_sb); 680 kfree(cifs_sb);
682 out_nls: 681 out_nls:
683 unload_nls(volume_info->local_nls); 682 unload_nls(volume_info->local_nls);
684 goto out; 683 goto out;
685 } 684 }
686 685
687 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov, 686 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
688 unsigned long nr_segs, loff_t pos) 687 unsigned long nr_segs, loff_t pos)
689 { 688 {
690 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode; 689 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
691 ssize_t written; 690 ssize_t written;
692 int rc; 691 int rc;
693 692
694 written = generic_file_aio_write(iocb, iov, nr_segs, pos); 693 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
695 694
696 if (CIFS_I(inode)->clientCanCacheAll) 695 if (CIFS_I(inode)->clientCanCacheAll)
697 return written; 696 return written;
698 697
699 rc = filemap_fdatawrite(inode->i_mapping); 698 rc = filemap_fdatawrite(inode->i_mapping);
700 if (rc) 699 if (rc)
701 cFYI(1, "cifs_file_aio_write: %d rc on %p inode", rc, inode); 700 cFYI(1, "cifs_file_aio_write: %d rc on %p inode", rc, inode);
702 701
703 return written; 702 return written;
704 } 703 }
705 704
706 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin) 705 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
707 { 706 {
708 /* 707 /*
709 * origin == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate 708 * origin == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
710 * the cached file length 709 * the cached file length
711 */ 710 */
712 if (origin != SEEK_SET && origin != SEEK_CUR) { 711 if (origin != SEEK_SET && origin != SEEK_CUR) {
713 int rc; 712 int rc;
714 struct inode *inode = file->f_path.dentry->d_inode; 713 struct inode *inode = file->f_path.dentry->d_inode;
715 714
716 /* 715 /*
717 * We need to be sure that all dirty pages are written and the 716 * We need to be sure that all dirty pages are written and the
718 * server has the newest file length. 717 * server has the newest file length.
719 */ 718 */
720 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping && 719 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
721 inode->i_mapping->nrpages != 0) { 720 inode->i_mapping->nrpages != 0) {
722 rc = filemap_fdatawait(inode->i_mapping); 721 rc = filemap_fdatawait(inode->i_mapping);
723 if (rc) { 722 if (rc) {
724 mapping_set_error(inode->i_mapping, rc); 723 mapping_set_error(inode->i_mapping, rc);
725 return rc; 724 return rc;
726 } 725 }
727 } 726 }
728 /* 727 /*
729 * Some applications poll for the file length in this strange 728 * Some applications poll for the file length in this strange
730 * way so we must seek to end on non-oplocked files by 729 * way so we must seek to end on non-oplocked files by
731 * setting the revalidate time to zero. 730 * setting the revalidate time to zero.
732 */ 731 */
733 CIFS_I(inode)->time = 0; 732 CIFS_I(inode)->time = 0;
734 733
735 rc = cifs_revalidate_file_attr(file); 734 rc = cifs_revalidate_file_attr(file);
736 if (rc < 0) 735 if (rc < 0)
737 return (loff_t)rc; 736 return (loff_t)rc;
738 } 737 }
739 return generic_file_llseek(file, offset, origin); 738 return generic_file_llseek(file, offset, origin);
740 } 739 }
741 740
742 static int cifs_setlease(struct file *file, long arg, struct file_lock **lease) 741 static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
743 { 742 {
744 /* note that this is called by vfs setlease with lock_flocks held 743 /* note that this is called by vfs setlease with lock_flocks held
745 to protect *lease from going away */ 744 to protect *lease from going away */
746 struct inode *inode = file->f_path.dentry->d_inode; 745 struct inode *inode = file->f_path.dentry->d_inode;
747 struct cifsFileInfo *cfile = file->private_data; 746 struct cifsFileInfo *cfile = file->private_data;
748 747
749 if (!(S_ISREG(inode->i_mode))) 748 if (!(S_ISREG(inode->i_mode)))
750 return -EINVAL; 749 return -EINVAL;
751 750
752 /* check if file is oplocked */ 751 /* check if file is oplocked */
753 if (((arg == F_RDLCK) && 752 if (((arg == F_RDLCK) &&
754 (CIFS_I(inode)->clientCanCacheRead)) || 753 (CIFS_I(inode)->clientCanCacheRead)) ||
755 ((arg == F_WRLCK) && 754 ((arg == F_WRLCK) &&
756 (CIFS_I(inode)->clientCanCacheAll))) 755 (CIFS_I(inode)->clientCanCacheAll)))
757 return generic_setlease(file, arg, lease); 756 return generic_setlease(file, arg, lease);
758 else if (tlink_tcon(cfile->tlink)->local_lease && 757 else if (tlink_tcon(cfile->tlink)->local_lease &&
759 !CIFS_I(inode)->clientCanCacheRead) 758 !CIFS_I(inode)->clientCanCacheRead)
760 /* If the server claims to support oplock on this 759 /* If the server claims to support oplock on this
761 file, then we still need to check oplock even 760 file, then we still need to check oplock even
762 if the local_lease mount option is set, but there 761 if the local_lease mount option is set, but there
763 are servers which do not support oplock for which 762 are servers which do not support oplock for which
764 this mount option may be useful if the user 763 this mount option may be useful if the user
765 knows that the file won't be changed on the server 764 knows that the file won't be changed on the server
766 by anyone else */ 765 by anyone else */
767 return generic_setlease(file, arg, lease); 766 return generic_setlease(file, arg, lease);
768 else 767 else
769 return -EAGAIN; 768 return -EAGAIN;
770 } 769 }
771 770
772 struct file_system_type cifs_fs_type = { 771 struct file_system_type cifs_fs_type = {
773 .owner = THIS_MODULE, 772 .owner = THIS_MODULE,
774 .name = "cifs", 773 .name = "cifs",
775 .mount = cifs_do_mount, 774 .mount = cifs_do_mount,
776 .kill_sb = cifs_kill_sb, 775 .kill_sb = cifs_kill_sb,
777 /* .fs_flags */ 776 /* .fs_flags */
778 }; 777 };
779 const struct inode_operations cifs_dir_inode_ops = { 778 const struct inode_operations cifs_dir_inode_ops = {
780 .create = cifs_create, 779 .create = cifs_create,
781 .lookup = cifs_lookup, 780 .lookup = cifs_lookup,
782 .getattr = cifs_getattr, 781 .getattr = cifs_getattr,
783 .unlink = cifs_unlink, 782 .unlink = cifs_unlink,
784 .link = cifs_hardlink, 783 .link = cifs_hardlink,
785 .mkdir = cifs_mkdir, 784 .mkdir = cifs_mkdir,
786 .rmdir = cifs_rmdir, 785 .rmdir = cifs_rmdir,
787 .rename = cifs_rename, 786 .rename = cifs_rename,
788 .permission = cifs_permission, 787 .permission = cifs_permission,
789 /* revalidate:cifs_revalidate, */ 788 /* revalidate:cifs_revalidate, */
790 .setattr = cifs_setattr, 789 .setattr = cifs_setattr,
791 .symlink = cifs_symlink, 790 .symlink = cifs_symlink,
792 .mknod = cifs_mknod, 791 .mknod = cifs_mknod,
793 #ifdef CONFIG_CIFS_XATTR 792 #ifdef CONFIG_CIFS_XATTR
794 .setxattr = cifs_setxattr, 793 .setxattr = cifs_setxattr,
795 .getxattr = cifs_getxattr, 794 .getxattr = cifs_getxattr,
796 .listxattr = cifs_listxattr, 795 .listxattr = cifs_listxattr,
797 .removexattr = cifs_removexattr, 796 .removexattr = cifs_removexattr,
798 #endif 797 #endif
799 }; 798 };
800 799
801 const struct inode_operations cifs_file_inode_ops = { 800 const struct inode_operations cifs_file_inode_ops = {
802 /* revalidate:cifs_revalidate, */ 801 /* revalidate:cifs_revalidate, */
803 .setattr = cifs_setattr, 802 .setattr = cifs_setattr,
804 .getattr = cifs_getattr, /* do we need this anymore? */ 803 .getattr = cifs_getattr, /* do we need this anymore? */
805 .rename = cifs_rename, 804 .rename = cifs_rename,
806 .permission = cifs_permission, 805 .permission = cifs_permission,
807 #ifdef CONFIG_CIFS_XATTR 806 #ifdef CONFIG_CIFS_XATTR
808 .setxattr = cifs_setxattr, 807 .setxattr = cifs_setxattr,
809 .getxattr = cifs_getxattr, 808 .getxattr = cifs_getxattr,
810 .listxattr = cifs_listxattr, 809 .listxattr = cifs_listxattr,
811 .removexattr = cifs_removexattr, 810 .removexattr = cifs_removexattr,
812 #endif 811 #endif
813 }; 812 };
814 813
815 const struct inode_operations cifs_symlink_inode_ops = { 814 const struct inode_operations cifs_symlink_inode_ops = {
816 .readlink = generic_readlink, 815 .readlink = generic_readlink,
817 .follow_link = cifs_follow_link, 816 .follow_link = cifs_follow_link,
818 .put_link = cifs_put_link, 817 .put_link = cifs_put_link,
819 .permission = cifs_permission, 818 .permission = cifs_permission,
820 /* BB add the following two eventually */ 819 /* BB add the following two eventually */
821 /* revalidate: cifs_revalidate, 820 /* revalidate: cifs_revalidate,
822 setattr: cifs_notify_change, *//* BB do we need notify change */ 821 setattr: cifs_notify_change, *//* BB do we need notify change */
823 #ifdef CONFIG_CIFS_XATTR 822 #ifdef CONFIG_CIFS_XATTR
824 .setxattr = cifs_setxattr, 823 .setxattr = cifs_setxattr,
825 .getxattr = cifs_getxattr, 824 .getxattr = cifs_getxattr,
826 .listxattr = cifs_listxattr, 825 .listxattr = cifs_listxattr,
827 .removexattr = cifs_removexattr, 826 .removexattr = cifs_removexattr,
828 #endif 827 #endif
829 }; 828 };
830 829
831 const struct file_operations cifs_file_ops = { 830 const struct file_operations cifs_file_ops = {
832 .read = do_sync_read, 831 .read = do_sync_read,
833 .write = do_sync_write, 832 .write = do_sync_write,
834 .aio_read = generic_file_aio_read, 833 .aio_read = generic_file_aio_read,
835 .aio_write = cifs_file_aio_write, 834 .aio_write = cifs_file_aio_write,
836 .open = cifs_open, 835 .open = cifs_open,
837 .release = cifs_close, 836 .release = cifs_close,
838 .lock = cifs_lock, 837 .lock = cifs_lock,
839 .fsync = cifs_fsync, 838 .fsync = cifs_fsync,
840 .flush = cifs_flush, 839 .flush = cifs_flush,
841 .mmap = cifs_file_mmap, 840 .mmap = cifs_file_mmap,
842 .splice_read = generic_file_splice_read, 841 .splice_read = generic_file_splice_read,
843 .llseek = cifs_llseek, 842 .llseek = cifs_llseek,
844 #ifdef CONFIG_CIFS_POSIX 843 #ifdef CONFIG_CIFS_POSIX
845 .unlocked_ioctl = cifs_ioctl, 844 .unlocked_ioctl = cifs_ioctl,
846 #endif /* CONFIG_CIFS_POSIX */ 845 #endif /* CONFIG_CIFS_POSIX */
847 .setlease = cifs_setlease, 846 .setlease = cifs_setlease,
848 }; 847 };
849 848
850 const struct file_operations cifs_file_strict_ops = { 849 const struct file_operations cifs_file_strict_ops = {
851 .read = do_sync_read, 850 .read = do_sync_read,
852 .write = do_sync_write, 851 .write = do_sync_write,
853 .aio_read = cifs_strict_readv, 852 .aio_read = cifs_strict_readv,
854 .aio_write = cifs_strict_writev, 853 .aio_write = cifs_strict_writev,
855 .open = cifs_open, 854 .open = cifs_open,
856 .release = cifs_close, 855 .release = cifs_close,
857 .lock = cifs_lock, 856 .lock = cifs_lock,
858 .fsync = cifs_strict_fsync, 857 .fsync = cifs_strict_fsync,
859 .flush = cifs_flush, 858 .flush = cifs_flush,
860 .mmap = cifs_file_strict_mmap, 859 .mmap = cifs_file_strict_mmap,
861 .splice_read = generic_file_splice_read, 860 .splice_read = generic_file_splice_read,
862 .llseek = cifs_llseek, 861 .llseek = cifs_llseek,
863 #ifdef CONFIG_CIFS_POSIX 862 #ifdef CONFIG_CIFS_POSIX
864 .unlocked_ioctl = cifs_ioctl, 863 .unlocked_ioctl = cifs_ioctl,
865 #endif /* CONFIG_CIFS_POSIX */ 864 #endif /* CONFIG_CIFS_POSIX */
866 .setlease = cifs_setlease, 865 .setlease = cifs_setlease,
867 }; 866 };
868 867
869 const struct file_operations cifs_file_direct_ops = { 868 const struct file_operations cifs_file_direct_ops = {
870 /* BB reevaluate whether they can be done with directio, no cache */ 869 /* BB reevaluate whether they can be done with directio, no cache */
871 .read = do_sync_read, 870 .read = do_sync_read,
872 .write = do_sync_write, 871 .write = do_sync_write,
873 .aio_read = cifs_user_readv, 872 .aio_read = cifs_user_readv,
874 .aio_write = cifs_user_writev, 873 .aio_write = cifs_user_writev,
875 .open = cifs_open, 874 .open = cifs_open,
876 .release = cifs_close, 875 .release = cifs_close,
877 .lock = cifs_lock, 876 .lock = cifs_lock,
878 .fsync = cifs_fsync, 877 .fsync = cifs_fsync,
879 .flush = cifs_flush, 878 .flush = cifs_flush,
880 .mmap = cifs_file_mmap, 879 .mmap = cifs_file_mmap,
881 .splice_read = generic_file_splice_read, 880 .splice_read = generic_file_splice_read,
882 #ifdef CONFIG_CIFS_POSIX 881 #ifdef CONFIG_CIFS_POSIX
883 .unlocked_ioctl = cifs_ioctl, 882 .unlocked_ioctl = cifs_ioctl,
884 #endif /* CONFIG_CIFS_POSIX */ 883 #endif /* CONFIG_CIFS_POSIX */
885 .llseek = cifs_llseek, 884 .llseek = cifs_llseek,
886 .setlease = cifs_setlease, 885 .setlease = cifs_setlease,
887 }; 886 };
888 887
889 const struct file_operations cifs_file_nobrl_ops = { 888 const struct file_operations cifs_file_nobrl_ops = {
890 .read = do_sync_read, 889 .read = do_sync_read,
891 .write = do_sync_write, 890 .write = do_sync_write,
892 .aio_read = generic_file_aio_read, 891 .aio_read = generic_file_aio_read,
893 .aio_write = cifs_file_aio_write, 892 .aio_write = cifs_file_aio_write,
894 .open = cifs_open, 893 .open = cifs_open,
895 .release = cifs_close, 894 .release = cifs_close,
896 .fsync = cifs_fsync, 895 .fsync = cifs_fsync,
897 .flush = cifs_flush, 896 .flush = cifs_flush,
898 .mmap = cifs_file_mmap, 897 .mmap = cifs_file_mmap,
899 .splice_read = generic_file_splice_read, 898 .splice_read = generic_file_splice_read,
900 .llseek = cifs_llseek, 899 .llseek = cifs_llseek,
901 #ifdef CONFIG_CIFS_POSIX 900 #ifdef CONFIG_CIFS_POSIX
902 .unlocked_ioctl = cifs_ioctl, 901 .unlocked_ioctl = cifs_ioctl,
903 #endif /* CONFIG_CIFS_POSIX */ 902 #endif /* CONFIG_CIFS_POSIX */
904 .setlease = cifs_setlease, 903 .setlease = cifs_setlease,
905 }; 904 };
906 905
907 const struct file_operations cifs_file_strict_nobrl_ops = { 906 const struct file_operations cifs_file_strict_nobrl_ops = {
908 .read = do_sync_read, 907 .read = do_sync_read,
909 .write = do_sync_write, 908 .write = do_sync_write,
910 .aio_read = cifs_strict_readv, 909 .aio_read = cifs_strict_readv,
911 .aio_write = cifs_strict_writev, 910 .aio_write = cifs_strict_writev,
912 .open = cifs_open, 911 .open = cifs_open,
913 .release = cifs_close, 912 .release = cifs_close,
914 .fsync = cifs_strict_fsync, 913 .fsync = cifs_strict_fsync,
915 .flush = cifs_flush, 914 .flush = cifs_flush,
916 .mmap = cifs_file_strict_mmap, 915 .mmap = cifs_file_strict_mmap,
917 .splice_read = generic_file_splice_read, 916 .splice_read = generic_file_splice_read,
918 .llseek = cifs_llseek, 917 .llseek = cifs_llseek,
919 #ifdef CONFIG_CIFS_POSIX 918 #ifdef CONFIG_CIFS_POSIX
920 .unlocked_ioctl = cifs_ioctl, 919 .unlocked_ioctl = cifs_ioctl,
921 #endif /* CONFIG_CIFS_POSIX */ 920 #endif /* CONFIG_CIFS_POSIX */
922 .setlease = cifs_setlease, 921 .setlease = cifs_setlease,
923 }; 922 };
924 923
925 const struct file_operations cifs_file_direct_nobrl_ops = { 924 const struct file_operations cifs_file_direct_nobrl_ops = {
926 /* BB reevaluate whether they can be done with directio, no cache */ 925 /* BB reevaluate whether they can be done with directio, no cache */
927 .read = do_sync_read, 926 .read = do_sync_read,
928 .write = do_sync_write, 927 .write = do_sync_write,
929 .aio_read = cifs_user_readv, 928 .aio_read = cifs_user_readv,
930 .aio_write = cifs_user_writev, 929 .aio_write = cifs_user_writev,
931 .open = cifs_open, 930 .open = cifs_open,
932 .release = cifs_close, 931 .release = cifs_close,
933 .fsync = cifs_fsync, 932 .fsync = cifs_fsync,
934 .flush = cifs_flush, 933 .flush = cifs_flush,
935 .mmap = cifs_file_mmap, 934 .mmap = cifs_file_mmap,
936 .splice_read = generic_file_splice_read, 935 .splice_read = generic_file_splice_read,
937 #ifdef CONFIG_CIFS_POSIX 936 #ifdef CONFIG_CIFS_POSIX
938 .unlocked_ioctl = cifs_ioctl, 937 .unlocked_ioctl = cifs_ioctl,
939 #endif /* CONFIG_CIFS_POSIX */ 938 #endif /* CONFIG_CIFS_POSIX */
940 .llseek = cifs_llseek, 939 .llseek = cifs_llseek,
941 .setlease = cifs_setlease, 940 .setlease = cifs_setlease,
942 }; 941 };
943 942
944 const struct file_operations cifs_dir_ops = { 943 const struct file_operations cifs_dir_ops = {
945 .readdir = cifs_readdir, 944 .readdir = cifs_readdir,
946 .release = cifs_closedir, 945 .release = cifs_closedir,
947 .read = generic_read_dir, 946 .read = generic_read_dir,
948 .unlocked_ioctl = cifs_ioctl, 947 .unlocked_ioctl = cifs_ioctl,
949 .llseek = generic_file_llseek, 948 .llseek = generic_file_llseek,
950 }; 949 };
951 950
952 static void 951 static void
953 cifs_init_once(void *inode) 952 cifs_init_once(void *inode)
954 { 953 {
955 struct cifsInodeInfo *cifsi = inode; 954 struct cifsInodeInfo *cifsi = inode;
956 955
957 inode_init_once(&cifsi->vfs_inode); 956 inode_init_once(&cifsi->vfs_inode);
958 mutex_init(&cifsi->lock_mutex); 957 mutex_init(&cifsi->lock_mutex);
959 } 958 }
960 959
961 static int 960 static int
962 cifs_init_inodecache(void) 961 cifs_init_inodecache(void)
963 { 962 {
964 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache", 963 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
965 sizeof(struct cifsInodeInfo), 964 sizeof(struct cifsInodeInfo),
966 0, (SLAB_RECLAIM_ACCOUNT| 965 0, (SLAB_RECLAIM_ACCOUNT|
967 SLAB_MEM_SPREAD), 966 SLAB_MEM_SPREAD),
968 cifs_init_once); 967 cifs_init_once);
969 if (cifs_inode_cachep == NULL) 968 if (cifs_inode_cachep == NULL)
970 return -ENOMEM; 969 return -ENOMEM;
971 970
972 return 0; 971 return 0;
973 } 972 }
974 973
975 static void 974 static void
976 cifs_destroy_inodecache(void) 975 cifs_destroy_inodecache(void)
977 { 976 {
978 kmem_cache_destroy(cifs_inode_cachep); 977 kmem_cache_destroy(cifs_inode_cachep);
979 } 978 }
980 979
981 static int 980 static int
982 cifs_init_request_bufs(void) 981 cifs_init_request_bufs(void)
983 { 982 {
984 if (CIFSMaxBufSize < 8192) { 983 if (CIFSMaxBufSize < 8192) {
985 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum 984 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
986 Unicode path name has to fit in any SMB/CIFS path based frames */ 985 Unicode path name has to fit in any SMB/CIFS path based frames */
987 CIFSMaxBufSize = 8192; 986 CIFSMaxBufSize = 8192;
988 } else if (CIFSMaxBufSize > 1024*127) { 987 } else if (CIFSMaxBufSize > 1024*127) {
989 CIFSMaxBufSize = 1024 * 127; 988 CIFSMaxBufSize = 1024 * 127;
990 } else { 989 } else {
991 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/ 990 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
992 } 991 }
993 /* cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */ 992 /* cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
994 cifs_req_cachep = kmem_cache_create("cifs_request", 993 cifs_req_cachep = kmem_cache_create("cifs_request",
995 CIFSMaxBufSize + 994 CIFSMaxBufSize +
996 MAX_CIFS_HDR_SIZE, 0, 995 MAX_CIFS_HDR_SIZE, 0,
997 SLAB_HWCACHE_ALIGN, NULL); 996 SLAB_HWCACHE_ALIGN, NULL);
998 if (cifs_req_cachep == NULL) 997 if (cifs_req_cachep == NULL)
999 return -ENOMEM; 998 return -ENOMEM;
1000 999
1001 if (cifs_min_rcv < 1) 1000 if (cifs_min_rcv < 1)
1002 cifs_min_rcv = 1; 1001 cifs_min_rcv = 1;
1003 else if (cifs_min_rcv > 64) { 1002 else if (cifs_min_rcv > 64) {
1004 cifs_min_rcv = 64; 1003 cifs_min_rcv = 64;
1005 cERROR(1, "cifs_min_rcv set to maximum (64)"); 1004 cERROR(1, "cifs_min_rcv set to maximum (64)");
1006 } 1005 }
1007 1006
1008 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv, 1007 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1009 cifs_req_cachep); 1008 cifs_req_cachep);
1010 1009
1011 if (cifs_req_poolp == NULL) { 1010 if (cifs_req_poolp == NULL) {
1012 kmem_cache_destroy(cifs_req_cachep); 1011 kmem_cache_destroy(cifs_req_cachep);
1013 return -ENOMEM; 1012 return -ENOMEM;
1014 } 1013 }
1015 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and 1014 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1016 almost all handle based requests (but not write response, nor is it 1015 almost all handle based requests (but not write response, nor is it
1017 sufficient for path based requests). A smaller size would have 1016 sufficient for path based requests). A smaller size would have
1018 been more efficient (compacting multiple slab items on one 4k page) 1017 been more efficient (compacting multiple slab items on one 4k page)
1019 for the case in which debug was on, but this larger size allows 1018 for the case in which debug was on, but this larger size allows
1020 more SMBs to use small buffer alloc and is still much more 1019 more SMBs to use small buffer alloc and is still much more
1021 efficient to alloc 1 per page off the slab compared to 17K (5page) 1020 efficient to alloc 1 per page off the slab compared to 17K (5page)
1022 alloc of large cifs buffers even when page debugging is on */ 1021 alloc of large cifs buffers even when page debugging is on */
1023 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq", 1022 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
1024 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN, 1023 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1025 NULL); 1024 NULL);
1026 if (cifs_sm_req_cachep == NULL) { 1025 if (cifs_sm_req_cachep == NULL) {
1027 mempool_destroy(cifs_req_poolp); 1026 mempool_destroy(cifs_req_poolp);
1028 kmem_cache_destroy(cifs_req_cachep); 1027 kmem_cache_destroy(cifs_req_cachep);
1029 return -ENOMEM; 1028 return -ENOMEM;
1030 } 1029 }
1031 1030
1032 if (cifs_min_small < 2) 1031 if (cifs_min_small < 2)
1033 cifs_min_small = 2; 1032 cifs_min_small = 2;
1034 else if (cifs_min_small > 256) { 1033 else if (cifs_min_small > 256) {
1035 cifs_min_small = 256; 1034 cifs_min_small = 256;
1036 cFYI(1, "cifs_min_small set to maximum (256)"); 1035 cFYI(1, "cifs_min_small set to maximum (256)");
1037 } 1036 }
1038 1037
1039 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small, 1038 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1040 cifs_sm_req_cachep); 1039 cifs_sm_req_cachep);
1041 1040
1042 if (cifs_sm_req_poolp == NULL) { 1041 if (cifs_sm_req_poolp == NULL) {
1043 mempool_destroy(cifs_req_poolp); 1042 mempool_destroy(cifs_req_poolp);
1044 kmem_cache_destroy(cifs_req_cachep); 1043 kmem_cache_destroy(cifs_req_cachep);
1045 kmem_cache_destroy(cifs_sm_req_cachep); 1044 kmem_cache_destroy(cifs_sm_req_cachep);
1046 return -ENOMEM; 1045 return -ENOMEM;
1047 } 1046 }
1048 1047
1049 return 0; 1048 return 0;
1050 } 1049 }
1051 1050
1052 static void 1051 static void
1053 cifs_destroy_request_bufs(void) 1052 cifs_destroy_request_bufs(void)
1054 { 1053 {
1055 mempool_destroy(cifs_req_poolp); 1054 mempool_destroy(cifs_req_poolp);
1056 kmem_cache_destroy(cifs_req_cachep); 1055 kmem_cache_destroy(cifs_req_cachep);
1057 mempool_destroy(cifs_sm_req_poolp); 1056 mempool_destroy(cifs_sm_req_poolp);
1058 kmem_cache_destroy(cifs_sm_req_cachep); 1057 kmem_cache_destroy(cifs_sm_req_cachep);
1059 } 1058 }
1060 1059
1061 static int 1060 static int
1062 cifs_init_mids(void) 1061 cifs_init_mids(void)
1063 { 1062 {
1064 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids", 1063 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1065 sizeof(struct mid_q_entry), 0, 1064 sizeof(struct mid_q_entry), 0,
1066 SLAB_HWCACHE_ALIGN, NULL); 1065 SLAB_HWCACHE_ALIGN, NULL);
1067 if (cifs_mid_cachep == NULL) 1066 if (cifs_mid_cachep == NULL)
1068 return -ENOMEM; 1067 return -ENOMEM;
1069 1068
1070 /* 3 is a reasonable minimum number of simultaneous operations */ 1069 /* 3 is a reasonable minimum number of simultaneous operations */
1071 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep); 1070 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1072 if (cifs_mid_poolp == NULL) { 1071 if (cifs_mid_poolp == NULL) {
1073 kmem_cache_destroy(cifs_mid_cachep); 1072 kmem_cache_destroy(cifs_mid_cachep);
1074 return -ENOMEM; 1073 return -ENOMEM;
1075 } 1074 }
1076 1075
1077 return 0; 1076 return 0;
1078 } 1077 }
1079 1078
1080 static void 1079 static void
1081 cifs_destroy_mids(void) 1080 cifs_destroy_mids(void)
1082 { 1081 {
1083 mempool_destroy(cifs_mid_poolp); 1082 mempool_destroy(cifs_mid_poolp);
1084 kmem_cache_destroy(cifs_mid_cachep); 1083 kmem_cache_destroy(cifs_mid_cachep);
1085 } 1084 }
1086 1085
1087 static int __init 1086 static int __init
1088 init_cifs(void) 1087 init_cifs(void)
1089 { 1088 {
1090 int rc = 0; 1089 int rc = 0;
1091 cifs_proc_init(); 1090 cifs_proc_init();
1092 INIT_LIST_HEAD(&cifs_tcp_ses_list); 1091 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1093 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */ 1092 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1094 INIT_LIST_HEAD(&GlobalDnotifyReqList); 1093 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1095 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q); 1094 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1096 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */ 1095 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1097 /* 1096 /*
1098 * Initialize Global counters 1097 * Initialize Global counters
1099 */ 1098 */
1100 atomic_set(&sesInfoAllocCount, 0); 1099 atomic_set(&sesInfoAllocCount, 0);
1101 atomic_set(&tconInfoAllocCount, 0); 1100 atomic_set(&tconInfoAllocCount, 0);
1102 atomic_set(&tcpSesAllocCount, 0); 1101 atomic_set(&tcpSesAllocCount, 0);
1103 atomic_set(&tcpSesReconnectCount, 0); 1102 atomic_set(&tcpSesReconnectCount, 0);
1104 atomic_set(&tconInfoReconnectCount, 0); 1103 atomic_set(&tconInfoReconnectCount, 0);
1105 1104
1106 atomic_set(&bufAllocCount, 0); 1105 atomic_set(&bufAllocCount, 0);
1107 atomic_set(&smBufAllocCount, 0); 1106 atomic_set(&smBufAllocCount, 0);
1108 #ifdef CONFIG_CIFS_STATS2 1107 #ifdef CONFIG_CIFS_STATS2
1109 atomic_set(&totBufAllocCount, 0); 1108 atomic_set(&totBufAllocCount, 0);
1110 atomic_set(&totSmBufAllocCount, 0); 1109 atomic_set(&totSmBufAllocCount, 0);
1111 #endif /* CONFIG_CIFS_STATS2 */ 1110 #endif /* CONFIG_CIFS_STATS2 */
1112 1111
1113 atomic_set(&midCount, 0); 1112 atomic_set(&midCount, 0);
1114 GlobalCurrentXid = 0; 1113 GlobalCurrentXid = 0;
1115 GlobalTotalActiveXid = 0; 1114 GlobalTotalActiveXid = 0;
1116 GlobalMaxActiveXid = 0; 1115 GlobalMaxActiveXid = 0;
1117 spin_lock_init(&cifs_tcp_ses_lock); 1116 spin_lock_init(&cifs_tcp_ses_lock);
1118 spin_lock_init(&cifs_file_list_lock); 1117 spin_lock_init(&cifs_file_list_lock);
1119 spin_lock_init(&GlobalMid_Lock); 1118 spin_lock_init(&GlobalMid_Lock);
1120 1119
1121 if (cifs_max_pending < 2) { 1120 if (cifs_max_pending < 2) {
1122 cifs_max_pending = 2; 1121 cifs_max_pending = 2;
1123 cFYI(1, "cifs_max_pending set to min of 2"); 1122 cFYI(1, "cifs_max_pending set to min of 2");
1124 } else if (cifs_max_pending > CIFS_MAX_REQ) { 1123 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1125 cifs_max_pending = CIFS_MAX_REQ; 1124 cifs_max_pending = CIFS_MAX_REQ;
1126 cFYI(1, "cifs_max_pending set to max of %u", CIFS_MAX_REQ); 1125 cFYI(1, "cifs_max_pending set to max of %u", CIFS_MAX_REQ);
1127 } 1126 }
1128 1127
1129 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0); 1128 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1130 if (!cifsiod_wq) { 1129 if (!cifsiod_wq) {
1131 rc = -ENOMEM; 1130 rc = -ENOMEM;
1132 goto out_clean_proc; 1131 goto out_clean_proc;
1133 } 1132 }
1134 1133
1135 rc = cifs_fscache_register(); 1134 rc = cifs_fscache_register();
1136 if (rc) 1135 if (rc)
1137 goto out_destroy_wq; 1136 goto out_destroy_wq;
1138 1137
1139 rc = cifs_init_inodecache(); 1138 rc = cifs_init_inodecache();
1140 if (rc) 1139 if (rc)
1141 goto out_unreg_fscache; 1140 goto out_unreg_fscache;
1142 1141
1143 rc = cifs_init_mids(); 1142 rc = cifs_init_mids();
1144 if (rc) 1143 if (rc)
1145 goto out_destroy_inodecache; 1144 goto out_destroy_inodecache;
1146 1145
1147 rc = cifs_init_request_bufs(); 1146 rc = cifs_init_request_bufs();
1148 if (rc) 1147 if (rc)
1149 goto out_destroy_mids; 1148 goto out_destroy_mids;
1150 1149
1151 #ifdef CONFIG_CIFS_UPCALL 1150 #ifdef CONFIG_CIFS_UPCALL
1152 rc = register_key_type(&cifs_spnego_key_type); 1151 rc = register_key_type(&cifs_spnego_key_type);
1153 if (rc) 1152 if (rc)
1154 goto out_destroy_request_bufs; 1153 goto out_destroy_request_bufs;
1155 #endif /* CONFIG_CIFS_UPCALL */ 1154 #endif /* CONFIG_CIFS_UPCALL */
1156 1155
1157 #ifdef CONFIG_CIFS_ACL 1156 #ifdef CONFIG_CIFS_ACL
1158 rc = init_cifs_idmap(); 1157 rc = init_cifs_idmap();
1159 if (rc) 1158 if (rc)
1160 goto out_register_key_type; 1159 goto out_register_key_type;
1161 #endif /* CONFIG_CIFS_ACL */ 1160 #endif /* CONFIG_CIFS_ACL */
1162 1161
1163 rc = register_filesystem(&cifs_fs_type); 1162 rc = register_filesystem(&cifs_fs_type);
1164 if (rc) 1163 if (rc)
1165 goto out_init_cifs_idmap; 1164 goto out_init_cifs_idmap;
1166 1165
1167 return 0; 1166 return 0;
1168 1167
1169 out_init_cifs_idmap: 1168 out_init_cifs_idmap:
1170 #ifdef CONFIG_CIFS_ACL 1169 #ifdef CONFIG_CIFS_ACL
1171 exit_cifs_idmap(); 1170 exit_cifs_idmap();
1172 out_register_key_type: 1171 out_register_key_type:
1173 #endif 1172 #endif
1174 #ifdef CONFIG_CIFS_UPCALL 1173 #ifdef CONFIG_CIFS_UPCALL
1175 unregister_key_type(&cifs_spnego_key_type); 1174 unregister_key_type(&cifs_spnego_key_type);
1176 out_destroy_request_bufs: 1175 out_destroy_request_bufs:
1177 #endif 1176 #endif
1178 cifs_destroy_request_bufs(); 1177 cifs_destroy_request_bufs();
1179 out_destroy_mids: 1178 out_destroy_mids:
1180 cifs_destroy_mids(); 1179 cifs_destroy_mids();
1181 out_destroy_inodecache: 1180 out_destroy_inodecache:
1182 cifs_destroy_inodecache(); 1181 cifs_destroy_inodecache();
1183 out_unreg_fscache: 1182 out_unreg_fscache:
1184 cifs_fscache_unregister(); 1183 cifs_fscache_unregister();
1185 out_destroy_wq: 1184 out_destroy_wq:
1186 destroy_workqueue(cifsiod_wq); 1185 destroy_workqueue(cifsiod_wq);
1187 out_clean_proc: 1186 out_clean_proc:
1188 cifs_proc_clean(); 1187 cifs_proc_clean();
1189 return rc; 1188 return rc;
1190 } 1189 }
1191 1190
1192 static void __exit 1191 static void __exit
1193 exit_cifs(void) 1192 exit_cifs(void)
1194 { 1193 {
1195 cFYI(DBG2, "exit_cifs"); 1194 cFYI(DBG2, "exit_cifs");
1196 unregister_filesystem(&cifs_fs_type); 1195 unregister_filesystem(&cifs_fs_type);
1197 cifs_dfs_release_automount_timer(); 1196 cifs_dfs_release_automount_timer();
1198 #ifdef CONFIG_CIFS_ACL 1197 #ifdef CONFIG_CIFS_ACL
1199 cifs_destroy_idmaptrees(); 1198 cifs_destroy_idmaptrees();
1200 exit_cifs_idmap(); 1199 exit_cifs_idmap();
1201 #endif 1200 #endif
1202 #ifdef CONFIG_CIFS_UPCALL 1201 #ifdef CONFIG_CIFS_UPCALL
1203 unregister_key_type(&cifs_spnego_key_type); 1202 unregister_key_type(&cifs_spnego_key_type);
1204 #endif 1203 #endif
1205 cifs_destroy_request_bufs(); 1204 cifs_destroy_request_bufs();
1206 cifs_destroy_mids(); 1205 cifs_destroy_mids();
1207 cifs_destroy_inodecache(); 1206 cifs_destroy_inodecache();
1208 cifs_fscache_unregister(); 1207 cifs_fscache_unregister();
1209 destroy_workqueue(cifsiod_wq); 1208 destroy_workqueue(cifsiod_wq);
1210 cifs_proc_clean(); 1209 cifs_proc_clean();
1211 } 1210 }
1212 1211
1213 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>"); 1212 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1214 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */ 1213 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1215 MODULE_DESCRIPTION 1214 MODULE_DESCRIPTION
1216 ("VFS to access servers complying with the SNIA CIFS Specification " 1215 ("VFS to access servers complying with the SNIA CIFS Specification "
1217 "e.g. Samba and Windows"); 1216 "e.g. Samba and Windows");
1218 MODULE_VERSION(CIFS_VERSION); 1217 MODULE_VERSION(CIFS_VERSION);
1219 module_init(init_cifs) 1218 module_init(init_cifs)
1220 module_exit(exit_cifs) 1219 module_exit(exit_cifs)
1221 1220