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