]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - fs/cifs/cifsfs.c
[CIFS] fix typo
[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>
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) {
004c46b9 350/* BB add prepath to mount options displayed */
1da177e4 351 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
80909022
JL
352 if (tcon->ses) {
353 if (tcon->ses->userName)
1da177e4 354 seq_printf(s, ",username=%s",
80909022
JL
355 tcon->ses->userName);
356 if (tcon->ses->domainName)
1da177e4 357 seq_printf(s, ",domain=%s",
80909022
JL
358 tcon->ses->domainName);
359 server = tcon->ses->server;
360 if (server) {
361 seq_printf(s, ",addr=");
362 switch (server->addr.sockAddr6.
363 sin6_family) {
364 case AF_INET6:
365 seq_printf(s, NIP6_FMT,
366 NIP6(server->addr.sockAddr6.sin6_addr));
367 break;
368 case AF_INET:
369 seq_printf(s, NIPQUAD_FMT,
370 NIPQUAD(server->addr.sockAddr.sin_addr.s_addr));
371 break;
372 }
373 }
1da177e4 374 }
d5d18501 375 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) ||
80909022 376 !(tcon->unix_ext))
d5d18501
SF
377 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
378 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) ||
80909022 379 !(tcon->unix_ext))
d5d18501 380 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
80909022 381 if (!tcon->unix_ext) {
2b280fab
SF
382 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
383 cifs_sb->mnt_file_mode,
384 cifs_sb->mnt_dir_mode);
385 }
80909022 386 if (tcon->seal)
2b280fab 387 seq_printf(s, ",seal");
80909022 388 if (tcon->nocase)
2b280fab 389 seq_printf(s, ",nocase");
80909022 390 if (tcon->retry)
89562b77 391 seq_printf(s, ",hard");
1da177e4 392 }
80909022
JL
393 if (cifs_sb->prepath)
394 seq_printf(s, ",prepath=%s", cifs_sb->prepath);
4523cc30
SF
395 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
396 seq_printf(s, ",posixpaths");
2b280fab
SF
397 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
398 seq_printf(s, ",setuids");
399 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
400 seq_printf(s, ",serverino");
401 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
402 seq_printf(s, ",directio");
403 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
404 seq_printf(s, ",nouser_xattr");
405 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
406 seq_printf(s, ",mapchars");
407 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
408 seq_printf(s, ",sfu");
409 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
410 seq_printf(s, ",nobrl");
411 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
412 seq_printf(s, ",cifsacl");
413 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
414 seq_printf(s, ",dynperm");
415 if (m->mnt_sb->s_flags & MS_POSIXACL)
416 seq_printf(s, ",acl");
417
50c2f753
SF
418 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
419 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
1da177e4
LT
420 }
421 return 0;
422}
423
424#ifdef CONFIG_CIFS_QUOTA
50c2f753
SF
425int cifs_xquota_set(struct super_block *sb, int quota_type, qid_t qid,
426 struct fs_disk_quota *pdquota)
1da177e4
LT
427{
428 int xid;
429 int rc = 0;
430 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
431 struct cifsTconInfo *pTcon;
50c2f753 432
4523cc30 433 if (cifs_sb)
1da177e4
LT
434 pTcon = cifs_sb->tcon;
435 else
436 return -EIO;
437
438
439 xid = GetXid();
4523cc30 440 if (pTcon) {
50c2f753 441 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
1da177e4 442 } else {
95ba7362 443 rc = -EIO;
1da177e4
LT
444 }
445
446 FreeXid(xid);
447 return rc;
448}
449
50c2f753
SF
450int cifs_xquota_get(struct super_block *sb, int quota_type, qid_t qid,
451 struct fs_disk_quota *pdquota)
1da177e4
LT
452{
453 int xid;
454 int rc = 0;
455 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
456 struct cifsTconInfo *pTcon;
457
4523cc30 458 if (cifs_sb)
1da177e4
LT
459 pTcon = cifs_sb->tcon;
460 else
461 return -EIO;
462
463 xid = GetXid();
4523cc30 464 if (pTcon) {
50c2f753 465 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
1da177e4
LT
466 } else {
467 rc = -EIO;
468 }
469
470 FreeXid(xid);
471 return rc;
472}
473
50c2f753 474int cifs_xstate_set(struct super_block *sb, unsigned int flags, int operation)
1da177e4 475{
50c2f753 476 int xid;
1da177e4
LT
477 int rc = 0;
478 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
479 struct cifsTconInfo *pTcon;
480
4523cc30 481 if (cifs_sb)
1da177e4
LT
482 pTcon = cifs_sb->tcon;
483 else
484 return -EIO;
485
486 xid = GetXid();
4523cc30 487 if (pTcon) {
50c2f753 488 cFYI(1, ("flags: 0x%x operation: 0x%x", flags, operation));
1da177e4
LT
489 } else {
490 rc = -EIO;
491 }
492
493 FreeXid(xid);
494 return rc;
495}
496
50c2f753 497int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
1da177e4
LT
498{
499 int xid;
500 int rc = 0;
501 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
502 struct cifsTconInfo *pTcon;
503
4523cc30 504 if (cifs_sb) {
1da177e4
LT
505 pTcon = cifs_sb->tcon;
506 } else {
507 return -EIO;
508 }
509 xid = GetXid();
4523cc30 510 if (pTcon) {
50c2f753 511 cFYI(1, ("pqstats %p", qstats));
1da177e4
LT
512 } else {
513 rc = -EIO;
514 }
515
516 FreeXid(xid);
517 return rc;
518}
519
520static struct quotactl_ops cifs_quotactl_ops = {
521 .set_xquota = cifs_xquota_set,
6f7e8f37 522 .get_xquota = cifs_xquota_get,
1da177e4
LT
523 .set_xstate = cifs_xstate_set,
524 .get_xstate = cifs_xstate_get,
525};
526#endif
527
42faad99 528static void cifs_umount_begin(struct super_block *sb)
68058e75 529{
42faad99 530 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
50c2f753 531 struct cifsTconInfo *tcon;
68058e75 532
4523cc30 533 if (cifs_sb == NULL)
9e2e85f8
SF
534 return;
535
536 tcon = cifs_sb->tcon;
4523cc30 537 if (tcon == NULL)
9e2e85f8 538 return;
f1987b44
JL
539
540 read_lock(&cifs_tcp_ses_lock);
541 if (tcon->tc_count == 1)
5e1253b5 542 tcon->tidStatus = CifsExiting;
f1987b44 543 read_unlock(&cifs_tcp_ses_lock);
5e1253b5 544
3a5ff61c 545 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
7b7abfe3 546 /* cancel_notify_requests(tcon); */
50c2f753
SF
547 if (tcon->ses && tcon->ses->server) {
548 cFYI(1, ("wake up tasks now - umount begin not complete"));
9e2e85f8 549 wake_up_all(&tcon->ses->server->request_q);
6ab16d24
SF
550 wake_up_all(&tcon->ses->server->response_q);
551 msleep(1); /* yield */
552 /* we have to kick the requests once more */
553 wake_up_all(&tcon->ses->server->response_q);
554 msleep(1);
5e1253b5
SF
555 }
556/* BB FIXME - finish add checks for tidStatus BB */
68058e75
SF
557
558 return;
559}
68058e75 560
bf97d287
SF
561#ifdef CONFIG_CIFS_STATS2
562static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
563{
564 /* BB FIXME */
565 return 0;
566}
567#endif
568
1da177e4
LT
569static int cifs_remount(struct super_block *sb, int *flags, char *data)
570{
571 *flags |= MS_NODIRATIME;
572 return 0;
573}
574
ee9b6d61 575static const struct super_operations cifs_super_ops = {
1da177e4
LT
576 .put_super = cifs_put_super,
577 .statfs = cifs_statfs,
578 .alloc_inode = cifs_alloc_inode,
579 .destroy_inode = cifs_destroy_inode,
50c2f753
SF
580/* .drop_inode = generic_delete_inode,
581 .delete_inode = cifs_delete_inode, */ /* Do not need above two
582 functions unless later we add lazy close of inodes or unless the
583 kernel forgets to call us with the same number of releases (closes)
584 as opens */
1da177e4 585 .show_options = cifs_show_options,
7b7abfe3 586 .umount_begin = cifs_umount_begin,
1da177e4 587 .remount_fs = cifs_remount,
bf97d287 588#ifdef CONFIG_CIFS_STATS2
f46d3e11 589 .show_stats = cifs_show_stats,
bf97d287 590#endif
1da177e4
LT
591};
592
454e2398 593static int
1da177e4 594cifs_get_sb(struct file_system_type *fs_type,
454e2398 595 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
1da177e4
LT
596{
597 int rc;
598 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
599
600 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
601
602 if (IS_ERR(sb))
454e2398 603 return PTR_ERR(sb);
1da177e4
LT
604
605 sb->s_flags = flags;
606
9b04c997 607 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
1da177e4
LT
608 if (rc) {
609 up_write(&sb->s_umount);
610 deactivate_super(sb);
454e2398 611 return rc;
1da177e4
LT
612 }
613 sb->s_flags |= MS_ACTIVE;
454e2398 614 return simple_set_mnt(mnt, sb);
1da177e4
LT
615}
616
027445c3
BP
617static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
618 unsigned long nr_segs, loff_t pos)
1da177e4 619{
e6a00296 620 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
1da177e4
LT
621 ssize_t written;
622
027445c3 623 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
87c89dd7
SF
624 if (!CIFS_I(inode)->clientCanCacheAll)
625 filemap_fdatawrite(inode->i_mapping);
1da177e4
LT
626 return written;
627}
628
c32a0b68
SF
629static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
630{
631 /* origin == SEEK_END => we must revalidate the cached file length */
0889a944 632 if (origin == SEEK_END) {
030e9d81
SF
633 int retval;
634
635 /* some applications poll for the file length in this strange
636 way so we must seek to end on non-oplocked files by
637 setting the revalidate time to zero */
c33f8d32 638 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
030e9d81
SF
639
640 retval = cifs_revalidate(file->f_path.dentry);
c32a0b68
SF
641 if (retval < 0)
642 return (loff_t)retval;
643 }
9465efc9 644 return generic_file_llseek_unlocked(file, offset, origin);
c32a0b68
SF
645}
646
84210e91
SF
647#ifdef CONFIG_CIFS_EXPERIMENTAL
648static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
649{
650 /* note that this is called by vfs setlease with the BKL held
651 although I doubt that BKL is needed here in cifs */
652 struct inode *inode = file->f_path.dentry->d_inode;
653
654 if (!(S_ISREG(inode->i_mode)))
655 return -EINVAL;
656
657 /* check if file is oplocked */
658 if (((arg == F_RDLCK) &&
659 (CIFS_I(inode)->clientCanCacheRead)) ||
660 ((arg == F_WRLCK) &&
661 (CIFS_I(inode)->clientCanCacheAll)))
662 return generic_setlease(file, arg, lease);
663 else if (CIFS_SB(inode->i_sb)->tcon->local_lease &&
664 !CIFS_I(inode)->clientCanCacheRead)
665 /* If the server claims to support oplock on this
666 file, then we still need to check oplock even
667 if the local_lease mount option is set, but there
668 are servers which do not support oplock for which
669 this mount option may be useful if the user
670 knows that the file won't be changed on the server
671 by anyone else */
672 return generic_setlease(file, arg, lease);
673 else
674 return -EAGAIN;
675}
676#endif
677
e6ab1582 678struct file_system_type cifs_fs_type = {
1da177e4
LT
679 .owner = THIS_MODULE,
680 .name = "cifs",
681 .get_sb = cifs_get_sb,
682 .kill_sb = kill_anon_super,
683 /* .fs_flags */
684};
754661f1 685const struct inode_operations cifs_dir_inode_ops = {
1da177e4
LT
686 .create = cifs_create,
687 .lookup = cifs_lookup,
688 .getattr = cifs_getattr,
689 .unlink = cifs_unlink,
690 .link = cifs_hardlink,
691 .mkdir = cifs_mkdir,
692 .rmdir = cifs_rmdir,
693 .rename = cifs_rename,
694 .permission = cifs_permission,
695/* revalidate:cifs_revalidate, */
696 .setattr = cifs_setattr,
697 .symlink = cifs_symlink,
698 .mknod = cifs_mknod,
699#ifdef CONFIG_CIFS_XATTR
700 .setxattr = cifs_setxattr,
701 .getxattr = cifs_getxattr,
702 .listxattr = cifs_listxattr,
703 .removexattr = cifs_removexattr,
704#endif
705};
706
754661f1 707const struct inode_operations cifs_file_inode_ops = {
1da177e4
LT
708/* revalidate:cifs_revalidate, */
709 .setattr = cifs_setattr,
710 .getattr = cifs_getattr, /* do we need this anymore? */
711 .rename = cifs_rename,
712 .permission = cifs_permission,
713#ifdef CONFIG_CIFS_XATTR
714 .setxattr = cifs_setxattr,
715 .getxattr = cifs_getxattr,
716 .listxattr = cifs_listxattr,
717 .removexattr = cifs_removexattr,
50c2f753 718#endif
1da177e4
LT
719};
720
754661f1 721const struct inode_operations cifs_symlink_inode_ops = {
50c2f753 722 .readlink = generic_readlink,
1da177e4
LT
723 .follow_link = cifs_follow_link,
724 .put_link = cifs_put_link,
725 .permission = cifs_permission,
726 /* BB add the following two eventually */
727 /* revalidate: cifs_revalidate,
728 setattr: cifs_notify_change, *//* BB do we need notify change */
729#ifdef CONFIG_CIFS_XATTR
730 .setxattr = cifs_setxattr,
731 .getxattr = cifs_getxattr,
732 .listxattr = cifs_listxattr,
733 .removexattr = cifs_removexattr,
50c2f753 734#endif
1da177e4
LT
735};
736
4b6f5d20 737const struct file_operations cifs_file_ops = {
87c89dd7
SF
738 .read = do_sync_read,
739 .write = do_sync_write,
87c89dd7
SF
740 .aio_read = generic_file_aio_read,
741 .aio_write = cifs_file_aio_write,
1da177e4
LT
742 .open = cifs_open,
743 .release = cifs_close,
744 .lock = cifs_lock,
745 .fsync = cifs_fsync,
746 .flush = cifs_flush,
747 .mmap = cifs_file_mmap,
5ffc4ef4 748 .splice_read = generic_file_splice_read,
c32a0b68 749 .llseek = cifs_llseek,
c67593a0 750#ifdef CONFIG_CIFS_POSIX
f9ddcca4 751 .unlocked_ioctl = cifs_ioctl,
c67593a0
SF
752#endif /* CONFIG_CIFS_POSIX */
753
1da177e4 754#ifdef CONFIG_CIFS_EXPERIMENTAL
1da177e4 755 .dir_notify = cifs_dir_notify,
84210e91 756 .setlease = cifs_setlease,
1da177e4
LT
757#endif /* CONFIG_CIFS_EXPERIMENTAL */
758};
759
4b6f5d20 760const struct file_operations cifs_file_direct_ops = {
50c2f753 761 /* no mmap, no aio, no readv -
1da177e4
LT
762 BB reevaluate whether they can be done with directio, no cache */
763 .read = cifs_user_read,
764 .write = cifs_user_write,
765 .open = cifs_open,
766 .release = cifs_close,
767 .lock = cifs_lock,
768 .fsync = cifs_fsync,
769 .flush = cifs_flush,
5ffc4ef4 770 .splice_read = generic_file_splice_read,
c67593a0 771#ifdef CONFIG_CIFS_POSIX
f9ddcca4 772 .unlocked_ioctl = cifs_ioctl,
c67593a0 773#endif /* CONFIG_CIFS_POSIX */
c32a0b68 774 .llseek = cifs_llseek,
1da177e4
LT
775#ifdef CONFIG_CIFS_EXPERIMENTAL
776 .dir_notify = cifs_dir_notify,
84210e91 777 .setlease = cifs_setlease,
1da177e4
LT
778#endif /* CONFIG_CIFS_EXPERIMENTAL */
779};
4b6f5d20 780const struct file_operations cifs_file_nobrl_ops = {
87c89dd7
SF
781 .read = do_sync_read,
782 .write = do_sync_write,
87c89dd7
SF
783 .aio_read = generic_file_aio_read,
784 .aio_write = cifs_file_aio_write,
785 .open = cifs_open,
786 .release = cifs_close,
787 .fsync = cifs_fsync,
788 .flush = cifs_flush,
789 .mmap = cifs_file_mmap,
5ffc4ef4 790 .splice_read = generic_file_splice_read,
c32a0b68 791 .llseek = cifs_llseek,
8b94bcb9 792#ifdef CONFIG_CIFS_POSIX
f9ddcca4 793 .unlocked_ioctl = cifs_ioctl,
8b94bcb9
SF
794#endif /* CONFIG_CIFS_POSIX */
795
796#ifdef CONFIG_CIFS_EXPERIMENTAL
87c89dd7 797 .dir_notify = cifs_dir_notify,
84210e91 798 .setlease = cifs_setlease,
8b94bcb9
SF
799#endif /* CONFIG_CIFS_EXPERIMENTAL */
800};
801
4b6f5d20 802const struct file_operations cifs_file_direct_nobrl_ops = {
50c2f753 803 /* no mmap, no aio, no readv -
87c89dd7
SF
804 BB reevaluate whether they can be done with directio, no cache */
805 .read = cifs_user_read,
806 .write = cifs_user_write,
807 .open = cifs_open,
808 .release = cifs_close,
809 .fsync = cifs_fsync,
810 .flush = cifs_flush,
5ffc4ef4 811 .splice_read = generic_file_splice_read,
8b94bcb9 812#ifdef CONFIG_CIFS_POSIX
f9ddcca4 813 .unlocked_ioctl = cifs_ioctl,
8b94bcb9 814#endif /* CONFIG_CIFS_POSIX */
c32a0b68 815 .llseek = cifs_llseek,
8b94bcb9 816#ifdef CONFIG_CIFS_EXPERIMENTAL
87c89dd7 817 .dir_notify = cifs_dir_notify,
84210e91 818 .setlease = cifs_setlease,
8b94bcb9
SF
819#endif /* CONFIG_CIFS_EXPERIMENTAL */
820};
1da177e4 821
4b6f5d20 822const struct file_operations cifs_dir_ops = {
1da177e4
LT
823 .readdir = cifs_readdir,
824 .release = cifs_closedir,
825 .read = generic_read_dir,
826#ifdef CONFIG_CIFS_EXPERIMENTAL
827 .dir_notify = cifs_dir_notify,
828#endif /* CONFIG_CIFS_EXPERIMENTAL */
f9ddcca4 829 .unlocked_ioctl = cifs_ioctl,
3222a3e5 830 .llseek = generic_file_llseek,
1da177e4
LT
831};
832
833static void
51cc5068 834cifs_init_once(void *inode)
1da177e4
LT
835{
836 struct cifsInodeInfo *cifsi = inode;
837
a35afb83
CL
838 inode_init_once(&cifsi->vfs_inode);
839 INIT_LIST_HEAD(&cifsi->lockList);
1da177e4
LT
840}
841
842static int
843cifs_init_inodecache(void)
844{
845 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
26f57364 846 sizeof(struct cifsInodeInfo),
fffb60f9
PJ
847 0, (SLAB_RECLAIM_ACCOUNT|
848 SLAB_MEM_SPREAD),
20c2df83 849 cifs_init_once);
1da177e4
LT
850 if (cifs_inode_cachep == NULL)
851 return -ENOMEM;
852
853 return 0;
854}
855
856static void
857cifs_destroy_inodecache(void)
858{
1a1d92c1 859 kmem_cache_destroy(cifs_inode_cachep);
1da177e4
LT
860}
861
862static int
863cifs_init_request_bufs(void)
864{
4523cc30 865 if (CIFSMaxBufSize < 8192) {
1da177e4
LT
866 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
867 Unicode path name has to fit in any SMB/CIFS path based frames */
868 CIFSMaxBufSize = 8192;
869 } else if (CIFSMaxBufSize > 1024*127) {
870 CIFSMaxBufSize = 1024 * 127;
871 } else {
872 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
873 }
874/* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
875 cifs_req_cachep = kmem_cache_create("cifs_request",
876 CIFSMaxBufSize +
877 MAX_CIFS_HDR_SIZE, 0,
20c2df83 878 SLAB_HWCACHE_ALIGN, NULL);
1da177e4
LT
879 if (cifs_req_cachep == NULL)
880 return -ENOMEM;
881
4523cc30 882 if (cifs_min_rcv < 1)
1da177e4
LT
883 cifs_min_rcv = 1;
884 else if (cifs_min_rcv > 64) {
885 cifs_min_rcv = 64;
50c2f753 886 cERROR(1, ("cifs_min_rcv set to maximum (64)"));
1da177e4
LT
887 }
888
93d2341c
MD
889 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
890 cifs_req_cachep);
1da177e4 891
4523cc30 892 if (cifs_req_poolp == NULL) {
1da177e4
LT
893 kmem_cache_destroy(cifs_req_cachep);
894 return -ENOMEM;
895 }
ec637e3f 896 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1da177e4
LT
897 almost all handle based requests (but not write response, nor is it
898 sufficient for path based requests). A smaller size would have
50c2f753 899 been more efficient (compacting multiple slab items on one 4k page)
1da177e4
LT
900 for the case in which debug was on, but this larger size allows
901 more SMBs to use small buffer alloc and is still much more
6dc0f87e 902 efficient to alloc 1 per page off the slab compared to 17K (5page)
1da177e4
LT
903 alloc of large cifs buffers even when page debugging is on */
904 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
6dc0f87e 905 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
20c2df83 906 NULL);
1da177e4
LT
907 if (cifs_sm_req_cachep == NULL) {
908 mempool_destroy(cifs_req_poolp);
909 kmem_cache_destroy(cifs_req_cachep);
6dc0f87e 910 return -ENOMEM;
1da177e4
LT
911 }
912
4523cc30 913 if (cifs_min_small < 2)
1da177e4
LT
914 cifs_min_small = 2;
915 else if (cifs_min_small > 256) {
916 cifs_min_small = 256;
6dc0f87e 917 cFYI(1, ("cifs_min_small set to maximum (256)"));
1da177e4
LT
918 }
919
93d2341c
MD
920 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
921 cifs_sm_req_cachep);
1da177e4 922
4523cc30 923 if (cifs_sm_req_poolp == NULL) {
1da177e4
LT
924 mempool_destroy(cifs_req_poolp);
925 kmem_cache_destroy(cifs_req_cachep);
926 kmem_cache_destroy(cifs_sm_req_cachep);
927 return -ENOMEM;
928 }
929
930 return 0;
931}
932
933static void
934cifs_destroy_request_bufs(void)
935{
936 mempool_destroy(cifs_req_poolp);
1a1d92c1 937 kmem_cache_destroy(cifs_req_cachep);
1da177e4 938 mempool_destroy(cifs_sm_req_poolp);
1a1d92c1 939 kmem_cache_destroy(cifs_sm_req_cachep);
1da177e4
LT
940}
941
942static int
943cifs_init_mids(void)
944{
945 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
26f57364
SF
946 sizeof(struct mid_q_entry), 0,
947 SLAB_HWCACHE_ALIGN, NULL);
1da177e4
LT
948 if (cifs_mid_cachep == NULL)
949 return -ENOMEM;
950
93d2341c
MD
951 /* 3 is a reasonable minimum number of simultaneous operations */
952 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
4523cc30 953 if (cifs_mid_poolp == NULL) {
1da177e4
LT
954 kmem_cache_destroy(cifs_mid_cachep);
955 return -ENOMEM;
956 }
957
958 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
26f57364
SF
959 sizeof(struct oplock_q_entry), 0,
960 SLAB_HWCACHE_ALIGN, NULL);
1da177e4 961 if (cifs_oplock_cachep == NULL) {
1da177e4 962 mempool_destroy(cifs_mid_poolp);
e6985c7f 963 kmem_cache_destroy(cifs_mid_cachep);
1da177e4
LT
964 return -ENOMEM;
965 }
966
967 return 0;
968}
969
970static void
971cifs_destroy_mids(void)
972{
973 mempool_destroy(cifs_mid_poolp);
1a1d92c1
AD
974 kmem_cache_destroy(cifs_mid_cachep);
975 kmem_cache_destroy(cifs_oplock_cachep);
1da177e4
LT
976}
977
50c2f753 978static int cifs_oplock_thread(void *dummyarg)
1da177e4 979{
6dc0f87e 980 struct oplock_q_entry *oplock_item;
1da177e4 981 struct cifsTconInfo *pTcon;
6dc0f87e 982 struct inode *inode;
1da177e4 983 __u16 netfid;
cea21805 984 int rc, waitrc = 0;
1da177e4 985
83144186 986 set_freezable();
1da177e4 987 do {
6dc0f87e 988 if (try_to_freeze())
ede1327e 989 continue;
50c2f753 990
1da177e4 991 spin_lock(&GlobalMid_Lock);
4523cc30 992 if (list_empty(&GlobalOplock_Q)) {
1da177e4
LT
993 spin_unlock(&GlobalMid_Lock);
994 set_current_state(TASK_INTERRUPTIBLE);
995 schedule_timeout(39*HZ);
996 } else {
6dc0f87e 997 oplock_item = list_entry(GlobalOplock_Q.next,
ad8b15f0
SF
998 struct oplock_q_entry, qhead);
999 cFYI(1, ("found oplock item to write out"));
1000 pTcon = oplock_item->tcon;
1001 inode = oplock_item->pinode;
1002 netfid = oplock_item->netfid;
1003 spin_unlock(&GlobalMid_Lock);
1004 DeleteOplockQEntry(oplock_item);
1005 /* can not grab inode sem here since it would
6dc0f87e 1006 deadlock when oplock received on delete
1b1dcc1b 1007 since vfs_unlink holds the i_mutex across
1da177e4 1008 the call */
ad8b15f0
SF
1009 /* mutex_lock(&inode->i_mutex);*/
1010 if (S_ISREG(inode->i_mode)) {
84210e91
SF
1011#ifdef CONFIG_CIFS_EXPERIMENTAL
1012 if (CIFS_I(inode)->clientCanCacheAll == 0)
1013 break_lease(inode, FMODE_READ);
1014 else if (CIFS_I(inode)->clientCanCacheRead == 0)
1015 break_lease(inode, FMODE_WRITE);
1016#endif
ad8b15f0
SF
1017 rc = filemap_fdatawrite(inode->i_mapping);
1018 if (CIFS_I(inode)->clientCanCacheRead == 0) {
1019 waitrc = filemap_fdatawait(
1020 inode->i_mapping);
1021 invalidate_remote_inode(inode);
1022 }
1023 if (rc == 0)
1024 rc = waitrc;
1025 } else
1026 rc = 0;
1027 /* mutex_unlock(&inode->i_mutex);*/
1028 if (rc)
1029 CIFS_I(inode)->write_behind_rc = rc;
1030 cFYI(1, ("Oplock flush inode %p rc %d",
1031 inode, rc));
6dc0f87e
SF
1032
1033 /* releasing stale oplock after recent reconnect
1034 of smb session using a now incorrect file
1035 handle is not a data integrity issue but do
1036 not bother sending an oplock release if session
1037 to server still is disconnected since oplock
1da177e4 1038 already released by the server in that case */
3b795210 1039 if (!pTcon->need_reconnect) {
ad8b15f0
SF
1040 rc = CIFSSMBLock(0, pTcon, netfid,
1041 0 /* len */ , 0 /* offset */, 0,
1042 0, LOCKING_ANDX_OPLOCK_RELEASE,
1043 false /* wait flag */);
1044 cFYI(1, ("Oplock release rc = %d", rc));
1045 }
68058e75
SF
1046 set_current_state(TASK_INTERRUPTIBLE);
1047 schedule_timeout(1); /* yield in case q were corrupt */
1da177e4 1048 }
45af7a0f
SF
1049 } while (!kthread_should_stop());
1050
1051 return 0;
1da177e4
LT
1052}
1053
954d7a1c 1054#ifdef CONFIG_CIFS_EXPERIMENTAL
50c2f753 1055static int cifs_dnotify_thread(void *dummyarg)
8d0d5094 1056{
6ab16d24 1057 struct list_head *tmp;
14fbf50d 1058 struct TCP_Server_Info *server;
6ab16d24 1059
8d0d5094 1060 do {
0fd1ffe0 1061 if (try_to_freeze())
16abbecd 1062 continue;
8d0d5094 1063 set_current_state(TASK_INTERRUPTIBLE);
6ab16d24 1064 schedule_timeout(15*HZ);
6ab16d24
SF
1065 /* check if any stuck requests that need
1066 to be woken up and wakeq so the
1067 thread can wake up and error out */
14fbf50d
JL
1068 read_lock(&cifs_tcp_ses_lock);
1069 list_for_each(tmp, &cifs_tcp_ses_list) {
1070 server = list_entry(tmp, struct TCP_Server_Info,
1071 tcp_ses_list);
1072 if (atomic_read(&server->inFlight))
1073 wake_up_all(&server->response_q);
6ab16d24 1074 }
14fbf50d 1075 read_unlock(&cifs_tcp_ses_lock);
45af7a0f
SF
1076 } while (!kthread_should_stop());
1077
1078 return 0;
1da177e4 1079}
954d7a1c 1080#endif
1da177e4
LT
1081
1082static int __init
1083init_cifs(void)
1084{
1085 int rc = 0;
1da177e4 1086 cifs_proc_init();
e7ddee90 1087 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1da177e4 1088 INIT_LIST_HEAD(&GlobalOplock_Q);
4ca9c190
SF
1089#ifdef CONFIG_CIFS_EXPERIMENTAL
1090 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1091 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
6dc0f87e 1092#endif
1da177e4
LT
1093/*
1094 * Initialize Global counters
1095 */
1096 atomic_set(&sesInfoAllocCount, 0);
1097 atomic_set(&tconInfoAllocCount, 0);
6dc0f87e 1098 atomic_set(&tcpSesAllocCount, 0);
1da177e4
LT
1099 atomic_set(&tcpSesReconnectCount, 0);
1100 atomic_set(&tconInfoReconnectCount, 0);
1101
1102 atomic_set(&bufAllocCount, 0);
4498eed5
SF
1103 atomic_set(&smBufAllocCount, 0);
1104#ifdef CONFIG_CIFS_STATS2
1105 atomic_set(&totBufAllocCount, 0);
1106 atomic_set(&totSmBufAllocCount, 0);
1107#endif /* CONFIG_CIFS_STATS2 */
1108
1da177e4
LT
1109 atomic_set(&midCount, 0);
1110 GlobalCurrentXid = 0;
1111 GlobalTotalActiveXid = 0;
1112 GlobalMaxActiveXid = 0;
2cd646a2 1113 memset(Local_System_Name, 0, 15);
1da177e4 1114 rwlock_init(&GlobalSMBSeslock);
e7ddee90 1115 rwlock_init(&cifs_tcp_ses_lock);
1da177e4
LT
1116 spin_lock_init(&GlobalMid_Lock);
1117
4523cc30 1118 if (cifs_max_pending < 2) {
1da177e4 1119 cifs_max_pending = 2;
6dc0f87e 1120 cFYI(1, ("cifs_max_pending set to min of 2"));
4523cc30 1121 } else if (cifs_max_pending > 256) {
1da177e4 1122 cifs_max_pending = 256;
6dc0f87e 1123 cFYI(1, ("cifs_max_pending set to max of 256"));
1da177e4
LT
1124 }
1125
1126 rc = cifs_init_inodecache();
45af7a0f
SF
1127 if (rc)
1128 goto out_clean_proc;
1129
1130 rc = cifs_init_mids();
1131 if (rc)
1132 goto out_destroy_inodecache;
1133
1134 rc = cifs_init_request_bufs();
1135 if (rc)
1136 goto out_destroy_mids;
1137
1138 rc = register_filesystem(&cifs_fs_type);
1139 if (rc)
1140 goto out_destroy_request_bufs;
84a15b93
JL
1141#ifdef CONFIG_CIFS_UPCALL
1142 rc = register_key_type(&cifs_spnego_key_type);
1143 if (rc)
1144 goto out_unregister_filesystem;
6103335d
SF
1145#endif
1146#ifdef CONFIG_CIFS_DFS_UPCALL
1147 rc = register_key_type(&key_type_dns_resolver);
1148 if (rc)
1149 goto out_unregister_key_type;
84a15b93 1150#endif
45af7a0f
SF
1151 oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
1152 if (IS_ERR(oplockThread)) {
1153 rc = PTR_ERR(oplockThread);
6dc0f87e 1154 cERROR(1, ("error %d create oplock thread", rc));
6103335d 1155 goto out_unregister_dfs_key_type;
1da177e4 1156 }
45af7a0f 1157
954d7a1c 1158#ifdef CONFIG_CIFS_EXPERIMENTAL
45af7a0f
SF
1159 dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
1160 if (IS_ERR(dnotifyThread)) {
1161 rc = PTR_ERR(dnotifyThread);
6dc0f87e 1162 cERROR(1, ("error %d create dnotify thread", rc));
45af7a0f
SF
1163 goto out_stop_oplock_thread;
1164 }
954d7a1c 1165#endif
45af7a0f
SF
1166
1167 return 0;
1168
954d7a1c 1169#ifdef CONFIG_CIFS_EXPERIMENTAL
45af7a0f 1170 out_stop_oplock_thread:
954d7a1c 1171#endif
45af7a0f 1172 kthread_stop(oplockThread);
6103335d
SF
1173 out_unregister_dfs_key_type:
1174#ifdef CONFIG_CIFS_DFS_UPCALL
1175 unregister_key_type(&key_type_dns_resolver);
84a15b93 1176 out_unregister_key_type:
6103335d 1177#endif
84a15b93
JL
1178#ifdef CONFIG_CIFS_UPCALL
1179 unregister_key_type(&cifs_spnego_key_type);
45af7a0f 1180 out_unregister_filesystem:
84a15b93 1181#endif
45af7a0f
SF
1182 unregister_filesystem(&cifs_fs_type);
1183 out_destroy_request_bufs:
1184 cifs_destroy_request_bufs();
1185 out_destroy_mids:
1186 cifs_destroy_mids();
1187 out_destroy_inodecache:
1188 cifs_destroy_inodecache();
1189 out_clean_proc:
1da177e4 1190 cifs_proc_clean();
1da177e4
LT
1191 return rc;
1192}
1193
1194static void __exit
1195exit_cifs(void)
1196{
90c81e0b 1197 cFYI(DBG2, ("exit_cifs"));
1da177e4 1198 cifs_proc_clean();
6103335d 1199#ifdef CONFIG_CIFS_DFS_UPCALL
78d31a3a 1200 cifs_dfs_release_automount_timer();
6103335d
SF
1201 unregister_key_type(&key_type_dns_resolver);
1202#endif
84a15b93
JL
1203#ifdef CONFIG_CIFS_UPCALL
1204 unregister_key_type(&cifs_spnego_key_type);
1da177e4
LT
1205#endif
1206 unregister_filesystem(&cifs_fs_type);
1207 cifs_destroy_inodecache();
1208 cifs_destroy_mids();
1209 cifs_destroy_request_bufs();
954d7a1c 1210#ifdef CONFIG_CIFS_EXPERIMENTAL
45af7a0f 1211 kthread_stop(dnotifyThread);
954d7a1c
JL
1212#endif
1213 kthread_stop(oplockThread);
1da177e4
LT
1214}
1215
1216MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
6dc0f87e 1217MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1da177e4 1218MODULE_DESCRIPTION
63135e08
SF
1219 ("VFS to access servers complying with the SNIA CIFS Specification "
1220 "e.g. Samba and Windows");
1da177e4
LT
1221MODULE_VERSION(CIFS_VERSION);
1222module_init(init_cifs)
1223module_exit(exit_cifs)