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