[CIFS] Fix build break from recent DFS patch when DFS support not enabled
[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>
1da177e4
LT
38#include "cifsfs.h"
39#include "cifspdu.h"
40#define DECLARE_GLOBALS_HERE
41#include "cifsglob.h"
42#include "cifsproto.h"
43#include "cifs_debug.h"
44#include "cifs_fs_sb.h"
45#include <linux/mm.h>
84a15b93 46#include <linux/key-type.h>
6103335d 47#include "dns_resolve.h"
e545937a 48#include "cifs_spnego.h"
1da177e4
LT
49#define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
50
51#ifdef CONFIG_CIFS_QUOTA
52static struct quotactl_ops cifs_quotactl_ops;
35c11fdd
SF
53#endif /* QUOTA */
54
1da177e4
LT
55int cifsFYI = 0;
56int cifsERROR = 1;
57int traceSMB = 0;
58unsigned int oplockEnabled = 1;
59unsigned int experimEnabled = 0;
60unsigned int linuxExtEnabled = 1;
61unsigned int lookupCacheEnabled = 1;
62unsigned int multiuser_mount = 0;
3979877e
SF
63unsigned int extended_security = CIFSSEC_DEF;
64/* unsigned int ntlmv2_support = 0; */
1da177e4 65unsigned int sign_CIFS_PDUs = 1;
6dc0f87e
SF
66extern struct task_struct *oplockThread; /* remove sparse warning */
67struct task_struct *oplockThread = NULL;
99ee4dbd 68/* extern struct task_struct * dnotifyThread; remove sparse warning */
954d7a1c 69#ifdef CONFIG_CIFS_EXPERIMENTAL
6dc0f87e 70static struct task_struct *dnotifyThread = NULL;
954d7a1c 71#endif
ee9b6d61 72static const struct super_operations cifs_super_ops;
1da177e4
LT
73unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
74module_param(CIFSMaxBufSize, int, 0);
63135e08
SF
75MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
76 "Default: 16384 Range: 8192 to 130048");
1da177e4
LT
77unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
78module_param(cifs_min_rcv, int, 0);
63135e08
SF
79MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
80 "1 to 64");
1da177e4
LT
81unsigned int cifs_min_small = 30;
82module_param(cifs_min_small, int, 0);
63135e08
SF
83MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
84 "Range: 2 to 256");
1da177e4
LT
85unsigned int cifs_max_pending = CIFS_MAX_REQ;
86module_param(cifs_max_pending, int, 0);
63135e08
SF
87MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
88 "Default: 50 Range: 2 to 256");
1da177e4 89
1da177e4
LT
90extern mempool_t *cifs_sm_req_poolp;
91extern mempool_t *cifs_req_poolp;
92extern mempool_t *cifs_mid_poolp;
93
e18b890b 94extern struct kmem_cache *cifs_oplock_cachep;
1da177e4
LT
95
96static int
97cifs_read_super(struct super_block *sb, void *data,
98 const char *devname, int silent)
99{
100 struct inode *inode;
101 struct cifs_sb_info *cifs_sb;
102 int rc = 0;
50c2f753 103
1b2b2126
SF
104 /* BB should we make this contingent on mount parm? */
105 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
790fe579 106 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
1da177e4 107 cifs_sb = CIFS_SB(sb);
4523cc30 108 if (cifs_sb == NULL)
1da177e4 109 return -ENOMEM;
1da177e4 110
e6ab1582
IM
111#ifdef CONFIG_CIFS_DFS_UPCALL
112 /* copy mount params to sb for use in submounts */
113 /* BB: should we move this after the mount so we
114 * do not have to do the copy on failed mounts?
115 * BB: May be it is better to do simple copy before
116 * complex operation (mount), and in case of fail
117 * just exit instead of doing mount and attempting
118 * undo it if this copy fails?*/
79ee9a8b
SF
119 if (data) {
120 int len = strlen(data);
121 cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
122 if (cifs_sb->mountdata == NULL) {
123 kfree(sb->s_fs_info);
124 sb->s_fs_info = NULL;
125 return -ENOMEM;
126 }
127 strncpy(cifs_sb->mountdata, data, len + 1);
128 cifs_sb->mountdata[len] = '\0';
e6ab1582 129 }
e6ab1582
IM
130#endif
131
1da177e4
LT
132 rc = cifs_mount(sb, cifs_sb, data, devname);
133
134 if (rc) {
135 if (!silent)
136 cERROR(1,
137 ("cifs_mount failed w/return code = %d", rc));
138 goto out_mount_failed;
139 }
140
141 sb->s_magic = CIFS_MAGIC_NUMBER;
142 sb->s_op = &cifs_super_ops;
4523cc30 143/* if (cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
790fe579
SF
144 sb->s_blocksize =
145 cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
1da177e4
LT
146#ifdef CONFIG_CIFS_QUOTA
147 sb->s_qcop = &cifs_quotactl_ops;
148#endif
149 sb->s_blocksize = CIFS_MAX_MSGSIZE;
150 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
ce634ab2 151 inode = cifs_iget(sb, ROOT_I);
1da177e4 152
ce634ab2
DH
153 if (IS_ERR(inode)) {
154 rc = PTR_ERR(inode);
155 inode = NULL;
1da177e4
LT
156 goto out_no_root;
157 }
158
159 sb->s_root = d_alloc_root(inode);
160
161 if (!sb->s_root) {
162 rc = -ENOMEM;
163 goto out_no_root;
164 }
50c2f753 165
7521a3c5
SF
166#ifdef CONFIG_CIFS_EXPERIMENTAL
167 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
168 cFYI(1, ("export ops supported"));
169 sb->s_export_op = &cifs_export_ops;
170 }
171#endif /* EXPERIMENTAL */
1da177e4
LT
172
173 return 0;
174
175out_no_root:
176 cERROR(1, ("cifs_read_super: get root inode failed"));
177 if (inode)
178 iput(inode);
54b4602d 179
2c731afb 180 cifs_umount(sb, cifs_sb);
1da177e4
LT
181
182out_mount_failed:
4523cc30 183 if (cifs_sb) {
e6ab1582
IM
184#ifdef CONFIG_CIFS_DFS_UPCALL
185 if (cifs_sb->mountdata) {
186 kfree(cifs_sb->mountdata);
187 cifs_sb->mountdata = NULL;
188 }
189#endif
4523cc30 190 if (cifs_sb->local_nls)
50c2f753 191 unload_nls(cifs_sb->local_nls);
1da177e4
LT
192 kfree(cifs_sb);
193 }
194 return rc;
195}
196
197static void
198cifs_put_super(struct super_block *sb)
199{
200 int rc = 0;
201 struct cifs_sb_info *cifs_sb;
202
203 cFYI(1, ("In cifs_put_super"));
204 cifs_sb = CIFS_SB(sb);
4523cc30 205 if (cifs_sb == NULL) {
790fe579 206 cFYI(1, ("Empty cifs superblock info passed to unmount"));
1da177e4
LT
207 return;
208 }
790fe579 209 rc = cifs_umount(sb, cifs_sb);
ad7a2926 210 if (rc)
1da177e4 211 cERROR(1, ("cifs_umount failed with return code %d", rc));
e6ab1582
IM
212#ifdef CONFIG_CIFS_DFS_UPCALL
213 if (cifs_sb->mountdata) {
214 kfree(cifs_sb->mountdata);
215 cifs_sb->mountdata = NULL;
216 }
217#endif
218
1da177e4
LT
219 unload_nls(cifs_sb->local_nls);
220 kfree(cifs_sb);
221 return;
222}
223
224static int
726c3342 225cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
1da177e4 226{
726c3342 227 struct super_block *sb = dentry->d_sb;
39da9847
SF
228 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
229 struct cifsTconInfo *tcon = cifs_sb->tcon;
c81156dd 230 int rc = -EOPNOTSUPP;
39da9847 231 int xid;
1da177e4
LT
232
233 xid = GetXid();
234
1da177e4
LT
235 buf->f_type = CIFS_MAGIC_NUMBER;
236
39da9847
SF
237 /*
238 * PATH_MAX may be too long - it would presumably be total path,
239 * but note that some servers (includinng Samba 3) have a shorter
240 * maximum path.
241 *
242 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
243 */
244 buf->f_namelen = PATH_MAX;
1da177e4
LT
245 buf->f_files = 0; /* undefined */
246 buf->f_ffree = 0; /* unlimited */
247
39da9847
SF
248 /*
249 * We could add a second check for a QFS Unix capability bit
250 */
251 if ((tcon->ses->capabilities & CAP_UNIX) &&
252 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
253 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
254
255 /*
256 * Only need to call the old QFSInfo if failed on newer one,
257 * e.g. by OS/2.
258 **/
259 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
260 rc = CIFSSMBQFSInfo(xid, tcon, buf);
261
262 /*
263 * Some old Windows servers also do not support level 103, retry with
264 * older level one if old server failed the previous call or we
265 * bypassed it because we detected that this was an older LANMAN sess
266 */
4523cc30 267 if (rc)
39da9847
SF
268 rc = SMBOldQFSInfo(xid, tcon, buf);
269
1da177e4 270 FreeXid(xid);
39da9847 271 return 0;
1da177e4
LT
272}
273
e6305c43 274static int cifs_permission(struct inode *inode, int mask)
1da177e4
LT
275{
276 struct cifs_sb_info *cifs_sb;
277
278 cifs_sb = CIFS_SB(inode->i_sb);
279
f696a365
MS
280 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
281 if ((mask & MAY_EXEC) && !execute_ok(inode))
282 return -EACCES;
283 else
284 return 0;
285 } else /* file mode might have been restricted at mount time
50c2f753 286 on the client (above and beyond ACL on servers) for
1da177e4 287 servers which do not support setting and viewing mode bits,
50c2f753 288 so allowing client to check permissions is useful */
1da177e4
LT
289 return generic_permission(inode, mask, NULL);
290}
291
e18b890b
CL
292static struct kmem_cache *cifs_inode_cachep;
293static struct kmem_cache *cifs_req_cachep;
294static struct kmem_cache *cifs_mid_cachep;
295struct kmem_cache *cifs_oplock_cachep;
296static struct kmem_cache *cifs_sm_req_cachep;
1da177e4
LT
297mempool_t *cifs_sm_req_poolp;
298mempool_t *cifs_req_poolp;
299mempool_t *cifs_mid_poolp;
300
301static struct inode *
302cifs_alloc_inode(struct super_block *sb)
303{
304 struct cifsInodeInfo *cifs_inode;
e94b1766 305 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
1da177e4
LT
306 if (!cifs_inode)
307 return NULL;
308 cifs_inode->cifsAttrs = 0x20; /* default */
309 atomic_set(&cifs_inode->inUse, 0);
310 cifs_inode->time = 0;
cea21805 311 cifs_inode->write_behind_rc = 0;
1da177e4
LT
312 /* Until the file is open and we have gotten oplock
313 info back from the server, can not assume caching of
314 file data or metadata */
4b18f2a9
SF
315 cifs_inode->clientCanCacheRead = false;
316 cifs_inode->clientCanCacheAll = false;
9a8165fc 317 cifs_inode->delete_pending = false;
1da177e4 318 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
50c2f753 319
1b2b2126
SF
320 /* Can not set i_flags here - they get immediately overwritten
321 to zero by the VFS */
322/* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
1da177e4
LT
323 INIT_LIST_HEAD(&cifs_inode->openFileList);
324 return &cifs_inode->vfs_inode;
325}
326
327static void
328cifs_destroy_inode(struct inode *inode)
329{
330 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
331}
332
333/*
334 * cifs_show_options() is for displaying mount options in /proc/mounts.
335 * Not all settable options are displayed but most of the important
336 * ones are.
337 */
338static int
339cifs_show_options(struct seq_file *s, struct vfsmount *m)
340{
341 struct cifs_sb_info *cifs_sb;
80909022
JL
342 struct cifsTconInfo *tcon;
343 struct TCP_Server_Info *server;
1da177e4
LT
344
345 cifs_sb = CIFS_SB(m->mnt_sb);
346
347 if (cifs_sb) {
80909022
JL
348 tcon = cifs_sb->tcon;
349 if (tcon) {
1da177e4 350 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
80909022
JL
351 if (tcon->ses) {
352 if (tcon->ses->userName)
1da177e4 353 seq_printf(s, ",username=%s",
80909022
JL
354 tcon->ses->userName);
355 if (tcon->ses->domainName)
1da177e4 356 seq_printf(s, ",domain=%s",
80909022
JL
357 tcon->ses->domainName);
358 server = tcon->ses->server;
359 if (server) {
360 seq_printf(s, ",addr=");
361 switch (server->addr.sockAddr6.
362 sin6_family) {
363 case AF_INET6:
bf66542b
SR
364 seq_printf(s, "%pI6",
365 &server->addr.sockAddr6.sin6_addr);
80909022
JL
366 break;
367 case AF_INET:
bf66542b
SR
368 seq_printf(s, "%pI4",
369 &server->addr.sockAddr.sin_addr.s_addr);
80909022
JL
370 break;
371 }
372 }
1da177e4 373 }
d5d18501 374 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) ||
80909022 375 !(tcon->unix_ext))
d5d18501
SF
376 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
377 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) ||
80909022 378 !(tcon->unix_ext))
d5d18501 379 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
80909022 380 if (!tcon->unix_ext) {
2b280fab
SF
381 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
382 cifs_sb->mnt_file_mode,
383 cifs_sb->mnt_dir_mode);
384 }
80909022 385 if (tcon->seal)
2b280fab 386 seq_printf(s, ",seal");
80909022 387 if (tcon->nocase)
2b280fab 388 seq_printf(s, ",nocase");
80909022 389 if (tcon->retry)
89562b77 390 seq_printf(s, ",hard");
1da177e4 391 }
80909022
JL
392 if (cifs_sb->prepath)
393 seq_printf(s, ",prepath=%s", cifs_sb->prepath);
4523cc30
SF
394 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
395 seq_printf(s, ",posixpaths");
2b280fab
SF
396 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
397 seq_printf(s, ",setuids");
398 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
399 seq_printf(s, ",serverino");
400 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
401 seq_printf(s, ",directio");
402 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
403 seq_printf(s, ",nouser_xattr");
404 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
405 seq_printf(s, ",mapchars");
406 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
407 seq_printf(s, ",sfu");
408 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
409 seq_printf(s, ",nobrl");
410 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
411 seq_printf(s, ",cifsacl");
412 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
413 seq_printf(s, ",dynperm");
414 if (m->mnt_sb->s_flags & MS_POSIXACL)
415 seq_printf(s, ",acl");
416
50c2f753
SF
417 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
418 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
1da177e4
LT
419 }
420 return 0;
421}
422
423#ifdef CONFIG_CIFS_QUOTA
50c2f753
SF
424int cifs_xquota_set(struct super_block *sb, int quota_type, qid_t qid,
425 struct fs_disk_quota *pdquota)
1da177e4
LT
426{
427 int xid;
428 int rc = 0;
429 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
430 struct cifsTconInfo *pTcon;
50c2f753 431
4523cc30 432 if (cifs_sb)
1da177e4
LT
433 pTcon = cifs_sb->tcon;
434 else
435 return -EIO;
436
437
438 xid = GetXid();
4523cc30 439 if (pTcon) {
50c2f753 440 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
61e74801 441 } else
95ba7362 442 rc = -EIO;
1da177e4
LT
443
444 FreeXid(xid);
445 return rc;
446}
447
50c2f753
SF
448int cifs_xquota_get(struct super_block *sb, int quota_type, qid_t qid,
449 struct fs_disk_quota *pdquota)
1da177e4
LT
450{
451 int xid;
452 int rc = 0;
453 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
454 struct cifsTconInfo *pTcon;
455
4523cc30 456 if (cifs_sb)
1da177e4
LT
457 pTcon = cifs_sb->tcon;
458 else
459 return -EIO;
460
461 xid = GetXid();
4523cc30 462 if (pTcon) {
50c2f753 463 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
61e74801 464 } else
1da177e4 465 rc = -EIO;
1da177e4
LT
466
467 FreeXid(xid);
468 return rc;
469}
470
50c2f753 471int cifs_xstate_set(struct super_block *sb, unsigned int flags, int operation)
1da177e4 472{
50c2f753 473 int xid;
1da177e4
LT
474 int rc = 0;
475 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
476 struct cifsTconInfo *pTcon;
477
4523cc30 478 if (cifs_sb)
1da177e4
LT
479 pTcon = cifs_sb->tcon;
480 else
481 return -EIO;
482
483 xid = GetXid();
4523cc30 484 if (pTcon) {
50c2f753 485 cFYI(1, ("flags: 0x%x operation: 0x%x", flags, operation));
61e74801 486 } else
1da177e4 487 rc = -EIO;
1da177e4
LT
488
489 FreeXid(xid);
490 return rc;
491}
492
50c2f753 493int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
1da177e4
LT
494{
495 int xid;
496 int rc = 0;
497 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
498 struct cifsTconInfo *pTcon;
499
61e74801 500 if (cifs_sb)
1da177e4 501 pTcon = cifs_sb->tcon;
61e74801 502 else
1da177e4 503 return -EIO;
61e74801 504
1da177e4 505 xid = GetXid();
4523cc30 506 if (pTcon) {
50c2f753 507 cFYI(1, ("pqstats %p", qstats));
61e74801 508 } else
1da177e4 509 rc = -EIO;
1da177e4
LT
510
511 FreeXid(xid);
512 return rc;
513}
514
515static struct quotactl_ops cifs_quotactl_ops = {
516 .set_xquota = cifs_xquota_set,
6f7e8f37 517 .get_xquota = cifs_xquota_get,
1da177e4
LT
518 .set_xstate = cifs_xstate_set,
519 .get_xstate = cifs_xstate_get,
520};
521#endif
522
42faad99 523static void cifs_umount_begin(struct super_block *sb)
68058e75 524{
42faad99 525 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
50c2f753 526 struct cifsTconInfo *tcon;
68058e75 527
4523cc30 528 if (cifs_sb == NULL)
9e2e85f8
SF
529 return;
530
531 tcon = cifs_sb->tcon;
4523cc30 532 if (tcon == NULL)
9e2e85f8 533 return;
f1987b44
JL
534
535 read_lock(&cifs_tcp_ses_lock);
536 if (tcon->tc_count == 1)
5e1253b5 537 tcon->tidStatus = CifsExiting;
f1987b44 538 read_unlock(&cifs_tcp_ses_lock);
5e1253b5 539
3a5ff61c 540 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
7b7abfe3 541 /* cancel_notify_requests(tcon); */
50c2f753
SF
542 if (tcon->ses && tcon->ses->server) {
543 cFYI(1, ("wake up tasks now - umount begin not complete"));
9e2e85f8 544 wake_up_all(&tcon->ses->server->request_q);
6ab16d24
SF
545 wake_up_all(&tcon->ses->server->response_q);
546 msleep(1); /* yield */
547 /* we have to kick the requests once more */
548 wake_up_all(&tcon->ses->server->response_q);
549 msleep(1);
5e1253b5
SF
550 }
551/* BB FIXME - finish add checks for tidStatus BB */
68058e75
SF
552
553 return;
554}
68058e75 555
bf97d287
SF
556#ifdef CONFIG_CIFS_STATS2
557static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
558{
559 /* BB FIXME */
560 return 0;
561}
562#endif
563
1da177e4
LT
564static int cifs_remount(struct super_block *sb, int *flags, char *data)
565{
566 *flags |= MS_NODIRATIME;
567 return 0;
568}
569
ee9b6d61 570static const struct super_operations cifs_super_ops = {
1da177e4
LT
571 .put_super = cifs_put_super,
572 .statfs = cifs_statfs,
573 .alloc_inode = cifs_alloc_inode,
574 .destroy_inode = cifs_destroy_inode,
50c2f753
SF
575/* .drop_inode = generic_delete_inode,
576 .delete_inode = cifs_delete_inode, */ /* Do not need above two
577 functions unless later we add lazy close of inodes or unless the
578 kernel forgets to call us with the same number of releases (closes)
579 as opens */
1da177e4 580 .show_options = cifs_show_options,
7b7abfe3 581 .umount_begin = cifs_umount_begin,
1da177e4 582 .remount_fs = cifs_remount,
bf97d287 583#ifdef CONFIG_CIFS_STATS2
f46d3e11 584 .show_stats = cifs_show_stats,
bf97d287 585#endif
1da177e4
LT
586};
587
454e2398 588static int
1da177e4 589cifs_get_sb(struct file_system_type *fs_type,
454e2398 590 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
1da177e4
LT
591{
592 int rc;
593 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
594
595 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
596
597 if (IS_ERR(sb))
454e2398 598 return PTR_ERR(sb);
1da177e4
LT
599
600 sb->s_flags = flags;
601
9b04c997 602 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
1da177e4
LT
603 if (rc) {
604 up_write(&sb->s_umount);
605 deactivate_super(sb);
454e2398 606 return rc;
1da177e4
LT
607 }
608 sb->s_flags |= MS_ACTIVE;
a3ec947c
SB
609 simple_set_mnt(mnt, sb);
610 return 0;
1da177e4
LT
611}
612
027445c3
BP
613static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
614 unsigned long nr_segs, loff_t pos)
1da177e4 615{
e6a00296 616 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
1da177e4
LT
617 ssize_t written;
618
027445c3 619 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
87c89dd7
SF
620 if (!CIFS_I(inode)->clientCanCacheAll)
621 filemap_fdatawrite(inode->i_mapping);
1da177e4
LT
622 return written;
623}
624
c32a0b68
SF
625static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
626{
627 /* origin == SEEK_END => we must revalidate the cached file length */
0889a944 628 if (origin == SEEK_END) {
030e9d81
SF
629 int retval;
630
631 /* some applications poll for the file length in this strange
632 way so we must seek to end on non-oplocked files by
633 setting the revalidate time to zero */
c33f8d32 634 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
030e9d81
SF
635
636 retval = cifs_revalidate(file->f_path.dentry);
c32a0b68
SF
637 if (retval < 0)
638 return (loff_t)retval;
639 }
9465efc9 640 return generic_file_llseek_unlocked(file, offset, origin);
c32a0b68
SF
641}
642
84210e91
SF
643#ifdef CONFIG_CIFS_EXPERIMENTAL
644static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
645{
646 /* note that this is called by vfs setlease with the BKL held
647 although I doubt that BKL is needed here in cifs */
648 struct inode *inode = file->f_path.dentry->d_inode;
649
650 if (!(S_ISREG(inode->i_mode)))
651 return -EINVAL;
652
653 /* check if file is oplocked */
654 if (((arg == F_RDLCK) &&
655 (CIFS_I(inode)->clientCanCacheRead)) ||
656 ((arg == F_WRLCK) &&
657 (CIFS_I(inode)->clientCanCacheAll)))
658 return generic_setlease(file, arg, lease);
659 else if (CIFS_SB(inode->i_sb)->tcon->local_lease &&
660 !CIFS_I(inode)->clientCanCacheRead)
661 /* If the server claims to support oplock on this
662 file, then we still need to check oplock even
663 if the local_lease mount option is set, but there
664 are servers which do not support oplock for which
665 this mount option may be useful if the user
666 knows that the file won't be changed on the server
667 by anyone else */
668 return generic_setlease(file, arg, lease);
669 else
670 return -EAGAIN;
671}
672#endif
673
e6ab1582 674struct file_system_type cifs_fs_type = {
1da177e4
LT
675 .owner = THIS_MODULE,
676 .name = "cifs",
677 .get_sb = cifs_get_sb,
678 .kill_sb = kill_anon_super,
679 /* .fs_flags */
680};
754661f1 681const struct inode_operations cifs_dir_inode_ops = {
1da177e4
LT
682 .create = cifs_create,
683 .lookup = cifs_lookup,
684 .getattr = cifs_getattr,
685 .unlink = cifs_unlink,
686 .link = cifs_hardlink,
687 .mkdir = cifs_mkdir,
688 .rmdir = cifs_rmdir,
689 .rename = cifs_rename,
690 .permission = cifs_permission,
691/* revalidate:cifs_revalidate, */
692 .setattr = cifs_setattr,
693 .symlink = cifs_symlink,
694 .mknod = cifs_mknod,
695#ifdef CONFIG_CIFS_XATTR
696 .setxattr = cifs_setxattr,
697 .getxattr = cifs_getxattr,
698 .listxattr = cifs_listxattr,
699 .removexattr = cifs_removexattr,
700#endif
701};
702
754661f1 703const struct inode_operations cifs_file_inode_ops = {
1da177e4
LT
704/* revalidate:cifs_revalidate, */
705 .setattr = cifs_setattr,
706 .getattr = cifs_getattr, /* do we need this anymore? */
707 .rename = cifs_rename,
708 .permission = cifs_permission,
709#ifdef CONFIG_CIFS_XATTR
710 .setxattr = cifs_setxattr,
711 .getxattr = cifs_getxattr,
712 .listxattr = cifs_listxattr,
713 .removexattr = cifs_removexattr,
50c2f753 714#endif
1da177e4
LT
715};
716
754661f1 717const struct inode_operations cifs_symlink_inode_ops = {
50c2f753 718 .readlink = generic_readlink,
1da177e4
LT
719 .follow_link = cifs_follow_link,
720 .put_link = cifs_put_link,
721 .permission = cifs_permission,
722 /* BB add the following two eventually */
723 /* revalidate: cifs_revalidate,
724 setattr: cifs_notify_change, *//* BB do we need notify change */
725#ifdef CONFIG_CIFS_XATTR
726 .setxattr = cifs_setxattr,
727 .getxattr = cifs_getxattr,
728 .listxattr = cifs_listxattr,
729 .removexattr = cifs_removexattr,
50c2f753 730#endif
1da177e4
LT
731};
732
4b6f5d20 733const struct file_operations cifs_file_ops = {
87c89dd7
SF
734 .read = do_sync_read,
735 .write = do_sync_write,
87c89dd7
SF
736 .aio_read = generic_file_aio_read,
737 .aio_write = cifs_file_aio_write,
1da177e4
LT
738 .open = cifs_open,
739 .release = cifs_close,
740 .lock = cifs_lock,
741 .fsync = cifs_fsync,
742 .flush = cifs_flush,
743 .mmap = cifs_file_mmap,
5ffc4ef4 744 .splice_read = generic_file_splice_read,
c32a0b68 745 .llseek = cifs_llseek,
c67593a0 746#ifdef CONFIG_CIFS_POSIX
f9ddcca4 747 .unlocked_ioctl = cifs_ioctl,
c67593a0
SF
748#endif /* CONFIG_CIFS_POSIX */
749
1da177e4 750#ifdef CONFIG_CIFS_EXPERIMENTAL
84210e91 751 .setlease = cifs_setlease,
1da177e4
LT
752#endif /* CONFIG_CIFS_EXPERIMENTAL */
753};
754
4b6f5d20 755const struct file_operations cifs_file_direct_ops = {
50c2f753 756 /* no mmap, no aio, no readv -
1da177e4
LT
757 BB reevaluate whether they can be done with directio, no cache */
758 .read = cifs_user_read,
759 .write = cifs_user_write,
760 .open = cifs_open,
761 .release = cifs_close,
762 .lock = cifs_lock,
763 .fsync = cifs_fsync,
764 .flush = cifs_flush,
5ffc4ef4 765 .splice_read = generic_file_splice_read,
c67593a0 766#ifdef CONFIG_CIFS_POSIX
f9ddcca4 767 .unlocked_ioctl = cifs_ioctl,
c67593a0 768#endif /* CONFIG_CIFS_POSIX */
c32a0b68 769 .llseek = cifs_llseek,
1da177e4 770#ifdef CONFIG_CIFS_EXPERIMENTAL
84210e91 771 .setlease = cifs_setlease,
1da177e4
LT
772#endif /* CONFIG_CIFS_EXPERIMENTAL */
773};
4b6f5d20 774const struct file_operations cifs_file_nobrl_ops = {
87c89dd7
SF
775 .read = do_sync_read,
776 .write = do_sync_write,
87c89dd7
SF
777 .aio_read = generic_file_aio_read,
778 .aio_write = cifs_file_aio_write,
779 .open = cifs_open,
780 .release = cifs_close,
781 .fsync = cifs_fsync,
782 .flush = cifs_flush,
783 .mmap = cifs_file_mmap,
5ffc4ef4 784 .splice_read = generic_file_splice_read,
c32a0b68 785 .llseek = cifs_llseek,
8b94bcb9 786#ifdef CONFIG_CIFS_POSIX
f9ddcca4 787 .unlocked_ioctl = cifs_ioctl,
8b94bcb9
SF
788#endif /* CONFIG_CIFS_POSIX */
789
790#ifdef CONFIG_CIFS_EXPERIMENTAL
84210e91 791 .setlease = cifs_setlease,
8b94bcb9
SF
792#endif /* CONFIG_CIFS_EXPERIMENTAL */
793};
794
4b6f5d20 795const struct file_operations cifs_file_direct_nobrl_ops = {
50c2f753 796 /* no mmap, no aio, no readv -
87c89dd7
SF
797 BB reevaluate whether they can be done with directio, no cache */
798 .read = cifs_user_read,
799 .write = cifs_user_write,
800 .open = cifs_open,
801 .release = cifs_close,
802 .fsync = cifs_fsync,
803 .flush = cifs_flush,
5ffc4ef4 804 .splice_read = generic_file_splice_read,
8b94bcb9 805#ifdef CONFIG_CIFS_POSIX
f9ddcca4 806 .unlocked_ioctl = cifs_ioctl,
8b94bcb9 807#endif /* CONFIG_CIFS_POSIX */
c32a0b68 808 .llseek = cifs_llseek,
8b94bcb9 809#ifdef CONFIG_CIFS_EXPERIMENTAL
84210e91 810 .setlease = cifs_setlease,
8b94bcb9
SF
811#endif /* CONFIG_CIFS_EXPERIMENTAL */
812};
1da177e4 813
4b6f5d20 814const struct file_operations cifs_dir_ops = {
1da177e4
LT
815 .readdir = cifs_readdir,
816 .release = cifs_closedir,
817 .read = generic_read_dir,
f9ddcca4 818 .unlocked_ioctl = cifs_ioctl,
3222a3e5 819 .llseek = generic_file_llseek,
1da177e4
LT
820};
821
822static void
51cc5068 823cifs_init_once(void *inode)
1da177e4
LT
824{
825 struct cifsInodeInfo *cifsi = inode;
826
a35afb83
CL
827 inode_init_once(&cifsi->vfs_inode);
828 INIT_LIST_HEAD(&cifsi->lockList);
1da177e4
LT
829}
830
831static int
832cifs_init_inodecache(void)
833{
834 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
26f57364 835 sizeof(struct cifsInodeInfo),
fffb60f9
PJ
836 0, (SLAB_RECLAIM_ACCOUNT|
837 SLAB_MEM_SPREAD),
20c2df83 838 cifs_init_once);
1da177e4
LT
839 if (cifs_inode_cachep == NULL)
840 return -ENOMEM;
841
842 return 0;
843}
844
845static void
846cifs_destroy_inodecache(void)
847{
1a1d92c1 848 kmem_cache_destroy(cifs_inode_cachep);
1da177e4
LT
849}
850
851static int
852cifs_init_request_bufs(void)
853{
4523cc30 854 if (CIFSMaxBufSize < 8192) {
1da177e4
LT
855 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
856 Unicode path name has to fit in any SMB/CIFS path based frames */
857 CIFSMaxBufSize = 8192;
858 } else if (CIFSMaxBufSize > 1024*127) {
859 CIFSMaxBufSize = 1024 * 127;
860 } else {
861 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
862 }
863/* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
864 cifs_req_cachep = kmem_cache_create("cifs_request",
865 CIFSMaxBufSize +
866 MAX_CIFS_HDR_SIZE, 0,
20c2df83 867 SLAB_HWCACHE_ALIGN, NULL);
1da177e4
LT
868 if (cifs_req_cachep == NULL)
869 return -ENOMEM;
870
4523cc30 871 if (cifs_min_rcv < 1)
1da177e4
LT
872 cifs_min_rcv = 1;
873 else if (cifs_min_rcv > 64) {
874 cifs_min_rcv = 64;
50c2f753 875 cERROR(1, ("cifs_min_rcv set to maximum (64)"));
1da177e4
LT
876 }
877
93d2341c
MD
878 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
879 cifs_req_cachep);
1da177e4 880
4523cc30 881 if (cifs_req_poolp == NULL) {
1da177e4
LT
882 kmem_cache_destroy(cifs_req_cachep);
883 return -ENOMEM;
884 }
ec637e3f 885 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1da177e4
LT
886 almost all handle based requests (but not write response, nor is it
887 sufficient for path based requests). A smaller size would have
50c2f753 888 been more efficient (compacting multiple slab items on one 4k page)
1da177e4
LT
889 for the case in which debug was on, but this larger size allows
890 more SMBs to use small buffer alloc and is still much more
6dc0f87e 891 efficient to alloc 1 per page off the slab compared to 17K (5page)
1da177e4
LT
892 alloc of large cifs buffers even when page debugging is on */
893 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
6dc0f87e 894 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
20c2df83 895 NULL);
1da177e4
LT
896 if (cifs_sm_req_cachep == NULL) {
897 mempool_destroy(cifs_req_poolp);
898 kmem_cache_destroy(cifs_req_cachep);
6dc0f87e 899 return -ENOMEM;
1da177e4
LT
900 }
901
4523cc30 902 if (cifs_min_small < 2)
1da177e4
LT
903 cifs_min_small = 2;
904 else if (cifs_min_small > 256) {
905 cifs_min_small = 256;
6dc0f87e 906 cFYI(1, ("cifs_min_small set to maximum (256)"));
1da177e4
LT
907 }
908
93d2341c
MD
909 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
910 cifs_sm_req_cachep);
1da177e4 911
4523cc30 912 if (cifs_sm_req_poolp == NULL) {
1da177e4
LT
913 mempool_destroy(cifs_req_poolp);
914 kmem_cache_destroy(cifs_req_cachep);
915 kmem_cache_destroy(cifs_sm_req_cachep);
916 return -ENOMEM;
917 }
918
919 return 0;
920}
921
922static void
923cifs_destroy_request_bufs(void)
924{
925 mempool_destroy(cifs_req_poolp);
1a1d92c1 926 kmem_cache_destroy(cifs_req_cachep);
1da177e4 927 mempool_destroy(cifs_sm_req_poolp);
1a1d92c1 928 kmem_cache_destroy(cifs_sm_req_cachep);
1da177e4
LT
929}
930
931static int
932cifs_init_mids(void)
933{
934 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
26f57364
SF
935 sizeof(struct mid_q_entry), 0,
936 SLAB_HWCACHE_ALIGN, NULL);
1da177e4
LT
937 if (cifs_mid_cachep == NULL)
938 return -ENOMEM;
939
93d2341c
MD
940 /* 3 is a reasonable minimum number of simultaneous operations */
941 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
4523cc30 942 if (cifs_mid_poolp == NULL) {
1da177e4
LT
943 kmem_cache_destroy(cifs_mid_cachep);
944 return -ENOMEM;
945 }
946
947 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
26f57364
SF
948 sizeof(struct oplock_q_entry), 0,
949 SLAB_HWCACHE_ALIGN, NULL);
1da177e4 950 if (cifs_oplock_cachep == NULL) {
1da177e4 951 mempool_destroy(cifs_mid_poolp);
e6985c7f 952 kmem_cache_destroy(cifs_mid_cachep);
1da177e4
LT
953 return -ENOMEM;
954 }
955
956 return 0;
957}
958
959static void
960cifs_destroy_mids(void)
961{
962 mempool_destroy(cifs_mid_poolp);
1a1d92c1
AD
963 kmem_cache_destroy(cifs_mid_cachep);
964 kmem_cache_destroy(cifs_oplock_cachep);
1da177e4
LT
965}
966
50c2f753 967static int cifs_oplock_thread(void *dummyarg)
1da177e4 968{
6dc0f87e 969 struct oplock_q_entry *oplock_item;
1da177e4 970 struct cifsTconInfo *pTcon;
6dc0f87e 971 struct inode *inode;
1da177e4 972 __u16 netfid;
cea21805 973 int rc, waitrc = 0;
1da177e4 974
83144186 975 set_freezable();
1da177e4 976 do {
6dc0f87e 977 if (try_to_freeze())
ede1327e 978 continue;
50c2f753 979
1da177e4 980 spin_lock(&GlobalMid_Lock);
4523cc30 981 if (list_empty(&GlobalOplock_Q)) {
1da177e4
LT
982 spin_unlock(&GlobalMid_Lock);
983 set_current_state(TASK_INTERRUPTIBLE);
984 schedule_timeout(39*HZ);
985 } else {
6dc0f87e 986 oplock_item = list_entry(GlobalOplock_Q.next,
ad8b15f0
SF
987 struct oplock_q_entry, qhead);
988 cFYI(1, ("found oplock item to write out"));
989 pTcon = oplock_item->tcon;
990 inode = oplock_item->pinode;
991 netfid = oplock_item->netfid;
992 spin_unlock(&GlobalMid_Lock);
993 DeleteOplockQEntry(oplock_item);
994 /* can not grab inode sem here since it would
6dc0f87e 995 deadlock when oplock received on delete
1b1dcc1b 996 since vfs_unlink holds the i_mutex across
1da177e4 997 the call */
ad8b15f0
SF
998 /* mutex_lock(&inode->i_mutex);*/
999 if (S_ISREG(inode->i_mode)) {
84210e91
SF
1000#ifdef CONFIG_CIFS_EXPERIMENTAL
1001 if (CIFS_I(inode)->clientCanCacheAll == 0)
1002 break_lease(inode, FMODE_READ);
1003 else if (CIFS_I(inode)->clientCanCacheRead == 0)
1004 break_lease(inode, FMODE_WRITE);
1005#endif
ad8b15f0
SF
1006 rc = filemap_fdatawrite(inode->i_mapping);
1007 if (CIFS_I(inode)->clientCanCacheRead == 0) {
1008 waitrc = filemap_fdatawait(
1009 inode->i_mapping);
1010 invalidate_remote_inode(inode);
1011 }
1012 if (rc == 0)
1013 rc = waitrc;
1014 } else
1015 rc = 0;
1016 /* mutex_unlock(&inode->i_mutex);*/
1017 if (rc)
1018 CIFS_I(inode)->write_behind_rc = rc;
1019 cFYI(1, ("Oplock flush inode %p rc %d",
1020 inode, rc));
6dc0f87e
SF
1021
1022 /* releasing stale oplock after recent reconnect
1023 of smb session using a now incorrect file
1024 handle is not a data integrity issue but do
1025 not bother sending an oplock release if session
1026 to server still is disconnected since oplock
1da177e4 1027 already released by the server in that case */
3b795210 1028 if (!pTcon->need_reconnect) {
ad8b15f0
SF
1029 rc = CIFSSMBLock(0, pTcon, netfid,
1030 0 /* len */ , 0 /* offset */, 0,
1031 0, LOCKING_ANDX_OPLOCK_RELEASE,
1032 false /* wait flag */);
1033 cFYI(1, ("Oplock release rc = %d", rc));
1034 }
68058e75
SF
1035 set_current_state(TASK_INTERRUPTIBLE);
1036 schedule_timeout(1); /* yield in case q were corrupt */
1da177e4 1037 }
45af7a0f
SF
1038 } while (!kthread_should_stop());
1039
1040 return 0;
1da177e4
LT
1041}
1042
954d7a1c 1043#ifdef CONFIG_CIFS_EXPERIMENTAL
50c2f753 1044static int cifs_dnotify_thread(void *dummyarg)
8d0d5094 1045{
6ab16d24 1046 struct list_head *tmp;
14fbf50d 1047 struct TCP_Server_Info *server;
6ab16d24 1048
8d0d5094 1049 do {
0fd1ffe0 1050 if (try_to_freeze())
16abbecd 1051 continue;
8d0d5094 1052 set_current_state(TASK_INTERRUPTIBLE);
6ab16d24 1053 schedule_timeout(15*HZ);
6ab16d24
SF
1054 /* check if any stuck requests that need
1055 to be woken up and wakeq so the
1056 thread can wake up and error out */
14fbf50d
JL
1057 read_lock(&cifs_tcp_ses_lock);
1058 list_for_each(tmp, &cifs_tcp_ses_list) {
1059 server = list_entry(tmp, struct TCP_Server_Info,
1060 tcp_ses_list);
1061 if (atomic_read(&server->inFlight))
1062 wake_up_all(&server->response_q);
6ab16d24 1063 }
14fbf50d 1064 read_unlock(&cifs_tcp_ses_lock);
45af7a0f
SF
1065 } while (!kthread_should_stop());
1066
1067 return 0;
1da177e4 1068}
954d7a1c 1069#endif
1da177e4
LT
1070
1071static int __init
1072init_cifs(void)
1073{
1074 int rc = 0;
1da177e4 1075 cifs_proc_init();
e7ddee90 1076 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1da177e4 1077 INIT_LIST_HEAD(&GlobalOplock_Q);
4ca9c190
SF
1078#ifdef CONFIG_CIFS_EXPERIMENTAL
1079 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1080 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
6dc0f87e 1081#endif
1da177e4
LT
1082/*
1083 * Initialize Global counters
1084 */
1085 atomic_set(&sesInfoAllocCount, 0);
1086 atomic_set(&tconInfoAllocCount, 0);
6dc0f87e 1087 atomic_set(&tcpSesAllocCount, 0);
1da177e4
LT
1088 atomic_set(&tcpSesReconnectCount, 0);
1089 atomic_set(&tconInfoReconnectCount, 0);
1090
1091 atomic_set(&bufAllocCount, 0);
4498eed5
SF
1092 atomic_set(&smBufAllocCount, 0);
1093#ifdef CONFIG_CIFS_STATS2
1094 atomic_set(&totBufAllocCount, 0);
1095 atomic_set(&totSmBufAllocCount, 0);
1096#endif /* CONFIG_CIFS_STATS2 */
1097
1da177e4
LT
1098 atomic_set(&midCount, 0);
1099 GlobalCurrentXid = 0;
1100 GlobalTotalActiveXid = 0;
1101 GlobalMaxActiveXid = 0;
2cd646a2 1102 memset(Local_System_Name, 0, 15);
1da177e4 1103 rwlock_init(&GlobalSMBSeslock);
e7ddee90 1104 rwlock_init(&cifs_tcp_ses_lock);
1da177e4
LT
1105 spin_lock_init(&GlobalMid_Lock);
1106
4523cc30 1107 if (cifs_max_pending < 2) {
1da177e4 1108 cifs_max_pending = 2;
6dc0f87e 1109 cFYI(1, ("cifs_max_pending set to min of 2"));
4523cc30 1110 } else if (cifs_max_pending > 256) {
1da177e4 1111 cifs_max_pending = 256;
6dc0f87e 1112 cFYI(1, ("cifs_max_pending set to max of 256"));
1da177e4
LT
1113 }
1114
1115 rc = cifs_init_inodecache();
45af7a0f
SF
1116 if (rc)
1117 goto out_clean_proc;
1118
1119 rc = cifs_init_mids();
1120 if (rc)
1121 goto out_destroy_inodecache;
1122
1123 rc = cifs_init_request_bufs();
1124 if (rc)
1125 goto out_destroy_mids;
1126
1127 rc = register_filesystem(&cifs_fs_type);
1128 if (rc)
1129 goto out_destroy_request_bufs;
84a15b93
JL
1130#ifdef CONFIG_CIFS_UPCALL
1131 rc = register_key_type(&cifs_spnego_key_type);
1132 if (rc)
1133 goto out_unregister_filesystem;
6103335d
SF
1134#endif
1135#ifdef CONFIG_CIFS_DFS_UPCALL
1136 rc = register_key_type(&key_type_dns_resolver);
1137 if (rc)
1138 goto out_unregister_key_type;
84a15b93 1139#endif
45af7a0f
SF
1140 oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
1141 if (IS_ERR(oplockThread)) {
1142 rc = PTR_ERR(oplockThread);
6dc0f87e 1143 cERROR(1, ("error %d create oplock thread", rc));
6103335d 1144 goto out_unregister_dfs_key_type;
1da177e4 1145 }
45af7a0f 1146
954d7a1c 1147#ifdef CONFIG_CIFS_EXPERIMENTAL
45af7a0f
SF
1148 dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
1149 if (IS_ERR(dnotifyThread)) {
1150 rc = PTR_ERR(dnotifyThread);
6dc0f87e 1151 cERROR(1, ("error %d create dnotify thread", rc));
45af7a0f
SF
1152 goto out_stop_oplock_thread;
1153 }
954d7a1c 1154#endif
45af7a0f
SF
1155
1156 return 0;
1157
954d7a1c 1158#ifdef CONFIG_CIFS_EXPERIMENTAL
45af7a0f 1159 out_stop_oplock_thread:
954d7a1c 1160#endif
45af7a0f 1161 kthread_stop(oplockThread);
6103335d
SF
1162 out_unregister_dfs_key_type:
1163#ifdef CONFIG_CIFS_DFS_UPCALL
1164 unregister_key_type(&key_type_dns_resolver);
84a15b93 1165 out_unregister_key_type:
6103335d 1166#endif
84a15b93
JL
1167#ifdef CONFIG_CIFS_UPCALL
1168 unregister_key_type(&cifs_spnego_key_type);
45af7a0f 1169 out_unregister_filesystem:
84a15b93 1170#endif
45af7a0f
SF
1171 unregister_filesystem(&cifs_fs_type);
1172 out_destroy_request_bufs:
1173 cifs_destroy_request_bufs();
1174 out_destroy_mids:
1175 cifs_destroy_mids();
1176 out_destroy_inodecache:
1177 cifs_destroy_inodecache();
1178 out_clean_proc:
1da177e4 1179 cifs_proc_clean();
1da177e4
LT
1180 return rc;
1181}
1182
1183static void __exit
1184exit_cifs(void)
1185{
90c81e0b 1186 cFYI(DBG2, ("exit_cifs"));
1da177e4 1187 cifs_proc_clean();
6103335d 1188#ifdef CONFIG_CIFS_DFS_UPCALL
78d31a3a 1189 cifs_dfs_release_automount_timer();
6103335d
SF
1190 unregister_key_type(&key_type_dns_resolver);
1191#endif
84a15b93
JL
1192#ifdef CONFIG_CIFS_UPCALL
1193 unregister_key_type(&cifs_spnego_key_type);
1da177e4
LT
1194#endif
1195 unregister_filesystem(&cifs_fs_type);
1196 cifs_destroy_inodecache();
1197 cifs_destroy_mids();
1198 cifs_destroy_request_bufs();
954d7a1c 1199#ifdef CONFIG_CIFS_EXPERIMENTAL
45af7a0f 1200 kthread_stop(dnotifyThread);
954d7a1c
JL
1201#endif
1202 kthread_stop(oplockThread);
1da177e4
LT
1203}
1204
1205MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
6dc0f87e 1206MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1da177e4 1207MODULE_DESCRIPTION
63135e08
SF
1208 ("VFS to access servers complying with the SNIA CIFS Specification "
1209 "e.g. Samba and Windows");
1da177e4
LT
1210MODULE_VERSION(CIFS_VERSION);
1211module_init(init_cifs)
1212module_exit(exit_cifs)