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