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