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