cifsfs.c 28.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/*
 *   fs/cifs/cifsfs.c
 *
4
 *   Copyright (C) International Business Machines  Corp., 2002,2008
L
Linus Torvalds 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
 *   Common Internet FileSystem (CIFS) client
 *
 *   This library is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Lesser General Public License as published
 *   by the Free Software Foundation; either version 2.1 of the License, or
 *   (at your option) any later version.
 *
 *   This library is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 *   the GNU Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public License
 *   along with this library; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

/* Note that BB means BUGBUG (ie something to fix eventually) */

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/mount.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/list.h>
#include <linux/seq_file.h>
#include <linux/vfs.h>
#include <linux/mempool.h>
35
#include <linux/delay.h>
36
#include <linux/kthread.h>
37
#include <linux/freezer.h>
38
#include <linux/smp_lock.h>
L
Linus Torvalds 已提交
39 40 41 42 43 44 45 46
#include "cifsfs.h"
#include "cifspdu.h"
#define DECLARE_GLOBALS_HERE
#include "cifsglob.h"
#include "cifsproto.h"
#include "cifs_debug.h"
#include "cifs_fs_sb.h"
#include <linux/mm.h>
47
#include <linux/key-type.h>
48
#include "dns_resolve.h"
49
#include "cifs_spnego.h"
L
Linus Torvalds 已提交
50 51 52
#define CIFS_MAGIC_NUMBER 0xFF534D42	/* the first four bytes of SMB PDUs */

#ifdef CONFIG_CIFS_QUOTA
53
static const struct quotactl_ops cifs_quotactl_ops;
S
Steve French 已提交
54 55
#endif /* QUOTA */

L
Linus Torvalds 已提交
56 57 58 59 60 61 62 63
int cifsFYI = 0;
int cifsERROR = 1;
int traceSMB = 0;
unsigned int oplockEnabled = 1;
unsigned int experimEnabled = 0;
unsigned int linuxExtEnabled = 1;
unsigned int lookupCacheEnabled = 1;
unsigned int multiuser_mount = 0;
64 65
unsigned int extended_security = CIFSSEC_DEF;
/* unsigned int ntlmv2_support = 0; */
L
Linus Torvalds 已提交
66
unsigned int sign_CIFS_PDUs = 1;
67
static const struct super_operations cifs_super_ops;
L
Linus Torvalds 已提交
68 69
unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
module_param(CIFSMaxBufSize, int, 0);
70 71
MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
				 "Default: 16384 Range: 8192 to 130048");
L
Linus Torvalds 已提交
72 73
unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
module_param(cifs_min_rcv, int, 0);
74 75
MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
				"1 to 64");
L
Linus Torvalds 已提交
76 77
unsigned int cifs_min_small = 30;
module_param(cifs_min_small, int, 0);
78 79
MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
				 "Range: 2 to 256");
L
Linus Torvalds 已提交
80 81
unsigned int cifs_max_pending = CIFS_MAX_REQ;
module_param(cifs_max_pending, int, 0);
82 83
MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
				   "Default: 50 Range: 2 to 256");
L
Linus Torvalds 已提交
84 85 86 87 88

extern mempool_t *cifs_sm_req_poolp;
extern mempool_t *cifs_req_poolp;
extern mempool_t *cifs_mid_poolp;

89
extern struct kmem_cache *cifs_oplock_cachep;
L
Linus Torvalds 已提交
90 91 92 93 94 95 96 97

static int
cifs_read_super(struct super_block *sb, void *data,
		const char *devname, int silent)
{
	struct inode *inode;
	struct cifs_sb_info *cifs_sb;
	int rc = 0;
98

99 100
	/* BB should we make this contingent on mount parm? */
	sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
S
Steve French 已提交
101
	sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
L
Linus Torvalds 已提交
102
	cifs_sb = CIFS_SB(sb);
103
	if (cifs_sb == NULL)
L
Linus Torvalds 已提交
104 105
		return -ENOMEM;

106 107 108 109 110 111 112 113
#ifdef CONFIG_CIFS_DFS_UPCALL
	/* copy mount params to sb for use in submounts */
	/* BB: should we move this after the mount so we
	 * do not have to do the copy on failed mounts?
	 * BB: May be it is better to do simple copy before
	 * complex operation (mount), and in case of fail
	 * just exit instead of doing mount and attempting
	 * undo it if this copy fails?*/
114 115 116 117 118 119 120 121 122 123
	if (data) {
		int len = strlen(data);
		cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
		if (cifs_sb->mountdata == NULL) {
			kfree(sb->s_fs_info);
			sb->s_fs_info = NULL;
			return -ENOMEM;
		}
		strncpy(cifs_sb->mountdata, data, len + 1);
		cifs_sb->mountdata[len] = '\0';
124 125 126
	}
#endif

L
Linus Torvalds 已提交
127 128 129 130 131 132 133 134 135 136 137
	rc = cifs_mount(sb, cifs_sb, data, devname);

	if (rc) {
		if (!silent)
			cERROR(1,
			       ("cifs_mount failed w/return code = %d", rc));
		goto out_mount_failed;
	}

	sb->s_magic = CIFS_MAGIC_NUMBER;
	sb->s_op = &cifs_super_ops;
138
/*	if (cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
S
Steve French 已提交
139 140
	    sb->s_blocksize =
		cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
L
Linus Torvalds 已提交
141 142 143 144 145
#ifdef CONFIG_CIFS_QUOTA
	sb->s_qcop = &cifs_quotactl_ops;
#endif
	sb->s_blocksize = CIFS_MAX_MSGSIZE;
	sb->s_blocksize_bits = 14;	/* default 2**14 = CIFS_MAX_MSGSIZE */
146
	inode = cifs_root_iget(sb, ROOT_I);
L
Linus Torvalds 已提交
147

148 149 150
	if (IS_ERR(inode)) {
		rc = PTR_ERR(inode);
		inode = NULL;
L
Linus Torvalds 已提交
151 152 153 154 155 156 157 158 159
		goto out_no_root;
	}

	sb->s_root = d_alloc_root(inode);

	if (!sb->s_root) {
		rc = -ENOMEM;
		goto out_no_root;
	}
160

161 162 163 164 165 166
#ifdef CONFIG_CIFS_EXPERIMENTAL
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
		cFYI(1, ("export ops supported"));
		sb->s_export_op = &cifs_export_ops;
	}
#endif /* EXPERIMENTAL */
L
Linus Torvalds 已提交
167 168 169 170 171 172 173

	return 0;

out_no_root:
	cERROR(1, ("cifs_read_super: get root inode failed"));
	if (inode)
		iput(inode);
S
Steve French 已提交
174

175
	cifs_umount(sb, cifs_sb);
L
Linus Torvalds 已提交
176 177

out_mount_failed:
178
	if (cifs_sb) {
179 180 181 182 183 184
#ifdef CONFIG_CIFS_DFS_UPCALL
		if (cifs_sb->mountdata) {
			kfree(cifs_sb->mountdata);
			cifs_sb->mountdata = NULL;
		}
#endif
185
		unload_nls(cifs_sb->local_nls);
L
Linus Torvalds 已提交
186 187 188 189 190 191 192 193 194 195 196 197 198
		kfree(cifs_sb);
	}
	return rc;
}

static void
cifs_put_super(struct super_block *sb)
{
	int rc = 0;
	struct cifs_sb_info *cifs_sb;

	cFYI(1, ("In cifs_put_super"));
	cifs_sb = CIFS_SB(sb);
199
	if (cifs_sb == NULL) {
S
Steve French 已提交
200
		cFYI(1, ("Empty cifs superblock info passed to unmount"));
L
Linus Torvalds 已提交
201 202
		return;
	}
203 204 205

	lock_kernel();

S
Steve French 已提交
206
	rc = cifs_umount(sb, cifs_sb);
S
Steve French 已提交
207
	if (rc)
L
Linus Torvalds 已提交
208
		cERROR(1, ("cifs_umount failed with return code %d", rc));
209 210 211 212 213 214 215
#ifdef CONFIG_CIFS_DFS_UPCALL
	if (cifs_sb->mountdata) {
		kfree(cifs_sb->mountdata);
		cifs_sb->mountdata = NULL;
	}
#endif

L
Linus Torvalds 已提交
216 217
	unload_nls(cifs_sb->local_nls);
	kfree(cifs_sb);
218 219

	unlock_kernel();
L
Linus Torvalds 已提交
220 221 222
}

static int
223
cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
L
Linus Torvalds 已提交
224
{
225
	struct super_block *sb = dentry->d_sb;
S
Steve French 已提交
226 227
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
	struct cifsTconInfo *tcon = cifs_sb->tcon;
228
	int rc = -EOPNOTSUPP;
S
Steve French 已提交
229
	int xid;
L
Linus Torvalds 已提交
230 231 232 233 234

	xid = GetXid();

	buf->f_type = CIFS_MAGIC_NUMBER;

S
Steve French 已提交
235 236 237 238 239 240 241 242
	/*
	 * PATH_MAX may be too long - it would presumably be total path,
	 * but note that some servers (includinng Samba 3) have a shorter
	 * maximum path.
	 *
	 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
	 */
	buf->f_namelen = PATH_MAX;
L
Linus Torvalds 已提交
243 244 245
	buf->f_files = 0;	/* undefined */
	buf->f_ffree = 0;	/* unlimited */

S
Steve French 已提交
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
	/*
	 * We could add a second check for a QFS Unix capability bit
	 */
	if ((tcon->ses->capabilities & CAP_UNIX) &&
	    (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
		rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);

	/*
	 * Only need to call the old QFSInfo if failed on newer one,
	 * e.g. by OS/2.
	 **/
	if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
		rc = CIFSSMBQFSInfo(xid, tcon, buf);

	/*
	 * Some old Windows servers also do not support level 103, retry with
	 * older level one if old server failed the previous call or we
	 * bypassed it because we detected that this was an older LANMAN sess
	 */
265
	if (rc)
S
Steve French 已提交
266 267
		rc = SMBOldQFSInfo(xid, tcon, buf);

L
Linus Torvalds 已提交
268
	FreeXid(xid);
S
Steve French 已提交
269
	return 0;
L
Linus Torvalds 已提交
270 271
}

272
static int cifs_permission(struct inode *inode, int mask)
L
Linus Torvalds 已提交
273 274 275 276 277
{
	struct cifs_sb_info *cifs_sb;

	cifs_sb = CIFS_SB(inode->i_sb);

278 279 280 281 282 283
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
		if ((mask & MAY_EXEC) && !execute_ok(inode))
			return -EACCES;
		else
			return 0;
	} else /* file mode might have been restricted at mount time
284
		on the client (above and beyond ACL on servers) for
L
Linus Torvalds 已提交
285
		servers which do not support setting and viewing mode bits,
286
		so allowing client to check permissions is useful */
L
Linus Torvalds 已提交
287 288 289
		return generic_permission(inode, mask, NULL);
}

290 291 292 293 294
static struct kmem_cache *cifs_inode_cachep;
static struct kmem_cache *cifs_req_cachep;
static struct kmem_cache *cifs_mid_cachep;
struct kmem_cache *cifs_oplock_cachep;
static struct kmem_cache *cifs_sm_req_cachep;
L
Linus Torvalds 已提交
295 296 297 298 299 300 301 302
mempool_t *cifs_sm_req_poolp;
mempool_t *cifs_req_poolp;
mempool_t *cifs_mid_poolp;

static struct inode *
cifs_alloc_inode(struct super_block *sb)
{
	struct cifsInodeInfo *cifs_inode;
303
	cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
L
Linus Torvalds 已提交
304 305 306 307
	if (!cifs_inode)
		return NULL;
	cifs_inode->cifsAttrs = 0x20;	/* default */
	cifs_inode->time = 0;
308
	cifs_inode->write_behind_rc = 0;
L
Linus Torvalds 已提交
309 310 311
	/* Until the file is open and we have gotten oplock
	info back from the server, can not assume caching of
	file data or metadata */
312 313
	cifs_inode->clientCanCacheRead = false;
	cifs_inode->clientCanCacheAll = false;
314
	cifs_inode->delete_pending = false;
L
Linus Torvalds 已提交
315
	cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
316
	cifs_inode->server_eof = 0;
317

318 319 320
	/* Can not set i_flags here - they get immediately overwritten
	   to zero by the VFS */
/*	cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
L
Linus Torvalds 已提交
321 322 323 324 325 326 327 328 329 330
	INIT_LIST_HEAD(&cifs_inode->openFileList);
	return &cifs_inode->vfs_inode;
}

static void
cifs_destroy_inode(struct inode *inode)
{
	kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
}

331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351
static void
cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
{
	seq_printf(s, ",addr=");

	switch (server->addr.sockAddr.sin_family) {
	case AF_INET:
		seq_printf(s, "%pI4", &server->addr.sockAddr.sin_addr.s_addr);
		break;
	case AF_INET6:
		seq_printf(s, "%pI6",
			   &server->addr.sockAddr6.sin6_addr.s6_addr);
		if (server->addr.sockAddr6.sin6_scope_id)
			seq_printf(s, "%%%u",
				   server->addr.sockAddr6.sin6_scope_id);
		break;
	default:
		seq_printf(s, "(unknown)");
	}
}

L
Linus Torvalds 已提交
352 353 354 355 356 357 358 359
/*
 * cifs_show_options() is for displaying mount options in /proc/mounts.
 * Not all settable options are displayed but most of the important
 * ones are.
 */
static int
cifs_show_options(struct seq_file *s, struct vfsmount *m)
{
360 361
	struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
	struct cifsTconInfo *tcon = cifs_sb->tcon;
362

363
	seq_printf(s, ",unc=%s", tcon->treeName);
364 365 366 367 368 369
	if (tcon->ses->userName)
		seq_printf(s, ",username=%s", tcon->ses->userName);
	if (tcon->ses->domainName)
		seq_printf(s, ",domain=%s", tcon->ses->domainName);

	seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
370 371
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
		seq_printf(s, ",forceuid");
372 373
	else
		seq_printf(s, ",noforceuid");
374

375
	seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
376 377
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
		seq_printf(s, ",forcegid");
378 379
	else
		seq_printf(s, ",noforcegid");
380

381
	cifs_show_address(s, tcon->ses->server);
L
Linus Torvalds 已提交
382

383 384
	if (!tcon->unix_ext)
		seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
385 386
					   cifs_sb->mnt_file_mode,
					   cifs_sb->mnt_dir_mode);
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
	if (tcon->seal)
		seq_printf(s, ",seal");
	if (tcon->nocase)
		seq_printf(s, ",nocase");
	if (tcon->retry)
		seq_printf(s, ",hard");
	if (cifs_sb->prepath)
		seq_printf(s, ",prepath=%s", cifs_sb->prepath);
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
		seq_printf(s, ",posixpaths");
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
		seq_printf(s, ",setuids");
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
		seq_printf(s, ",serverino");
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
		seq_printf(s, ",directio");
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
		seq_printf(s, ",nouser_xattr");
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
		seq_printf(s, ",mapchars");
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
		seq_printf(s, ",sfu");
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
		seq_printf(s, ",nobrl");
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
		seq_printf(s, ",cifsacl");
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
		seq_printf(s, ",dynperm");
	if (m->mnt_sb->s_flags & MS_POSIXACL)
		seq_printf(s, ",acl");

	seq_printf(s, ",rsize=%d", cifs_sb->rsize);
	seq_printf(s, ",wsize=%d", cifs_sb->wsize);

L
Linus Torvalds 已提交
421 422 423 424
	return 0;
}

#ifdef CONFIG_CIFS_QUOTA
425 426
int cifs_xquota_set(struct super_block *sb, int quota_type, qid_t qid,
		struct fs_disk_quota *pdquota)
L
Linus Torvalds 已提交
427 428 429 430 431
{
	int xid;
	int rc = 0;
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
	struct cifsTconInfo *pTcon;
432

433
	if (cifs_sb)
L
Linus Torvalds 已提交
434 435 436 437 438 439
		pTcon = cifs_sb->tcon;
	else
		return -EIO;


	xid = GetXid();
440
	if (pTcon) {
441
		cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
442
	} else
443
		rc = -EIO;
L
Linus Torvalds 已提交
444 445 446 447 448

	FreeXid(xid);
	return rc;
}

449 450
int cifs_xquota_get(struct super_block *sb, int quota_type, qid_t qid,
		    struct fs_disk_quota *pdquota)
L
Linus Torvalds 已提交
451 452 453 454 455 456
{
	int xid;
	int rc = 0;
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
	struct cifsTconInfo *pTcon;

457
	if (cifs_sb)
L
Linus Torvalds 已提交
458 459 460 461 462
		pTcon = cifs_sb->tcon;
	else
		return -EIO;

	xid = GetXid();
463
	if (pTcon) {
464
		cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
465
	} else
L
Linus Torvalds 已提交
466 467 468 469 470 471
		rc = -EIO;

	FreeXid(xid);
	return rc;
}

472
int cifs_xstate_set(struct super_block *sb, unsigned int flags, int operation)
L
Linus Torvalds 已提交
473
{
474
	int xid;
L
Linus Torvalds 已提交
475 476 477 478
	int rc = 0;
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
	struct cifsTconInfo *pTcon;

479
	if (cifs_sb)
L
Linus Torvalds 已提交
480 481 482 483 484
		pTcon = cifs_sb->tcon;
	else
		return -EIO;

	xid = GetXid();
485
	if (pTcon) {
486
		cFYI(1, ("flags: 0x%x operation: 0x%x", flags, operation));
487
	} else
L
Linus Torvalds 已提交
488 489 490 491 492 493
		rc = -EIO;

	FreeXid(xid);
	return rc;
}

494
int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
L
Linus Torvalds 已提交
495 496 497 498 499 500
{
	int xid;
	int rc = 0;
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
	struct cifsTconInfo *pTcon;

501
	if (cifs_sb)
L
Linus Torvalds 已提交
502
		pTcon = cifs_sb->tcon;
503
	else
L
Linus Torvalds 已提交
504
		return -EIO;
505

L
Linus Torvalds 已提交
506
	xid = GetXid();
507
	if (pTcon) {
508
		cFYI(1, ("pqstats %p", qstats));
509
	} else
L
Linus Torvalds 已提交
510 511 512 513 514 515
		rc = -EIO;

	FreeXid(xid);
	return rc;
}

516
static const struct quotactl_ops cifs_quotactl_ops = {
L
Linus Torvalds 已提交
517
	.set_xquota	= cifs_xquota_set,
R
Roel Kluin 已提交
518
	.get_xquota	= cifs_xquota_get,
L
Linus Torvalds 已提交
519 520 521 522 523
	.set_xstate	= cifs_xstate_set,
	.get_xstate	= cifs_xstate_get,
};
#endif

524
static void cifs_umount_begin(struct super_block *sb)
525
{
526
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
527
	struct cifsTconInfo *tcon;
528

529
	if (cifs_sb == NULL)
530 531 532
		return;

	tcon = cifs_sb->tcon;
533
	if (tcon == NULL)
534
		return;
535 536

	read_lock(&cifs_tcp_ses_lock);
537 538 539 540 541 542 543
	if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
		/* we have other mounts to same share or we have
		   already tried to force umount this and woken up
		   all waiting network requests, nothing to do */
		read_unlock(&cifs_tcp_ses_lock);
		return;
	} else if (tcon->tc_count == 1)
544
		tcon->tidStatus = CifsExiting;
545
	read_unlock(&cifs_tcp_ses_lock);
546

547
	/* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
S
Steve French 已提交
548
	/* cancel_notify_requests(tcon); */
549 550
	if (tcon->ses && tcon->ses->server) {
		cFYI(1, ("wake up tasks now - umount begin not complete"));
551
		wake_up_all(&tcon->ses->server->request_q);
552 553 554 555 556
		wake_up_all(&tcon->ses->server->response_q);
		msleep(1); /* yield */
		/* we have to kick the requests once more */
		wake_up_all(&tcon->ses->server->response_q);
		msleep(1);
557
	}
558 559 560 561

	return;
}

562 563 564 565 566 567 568 569
#ifdef CONFIG_CIFS_STATS2
static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
{
	/* BB FIXME */
	return 0;
}
#endif

L
Linus Torvalds 已提交
570 571 572 573 574 575
static int cifs_remount(struct super_block *sb, int *flags, char *data)
{
	*flags |= MS_NODIRATIME;
	return 0;
}

576
static const struct super_operations cifs_super_ops = {
L
Linus Torvalds 已提交
577 578 579 580
	.put_super = cifs_put_super,
	.statfs = cifs_statfs,
	.alloc_inode = cifs_alloc_inode,
	.destroy_inode = cifs_destroy_inode,
581 582 583 584 585
/*	.drop_inode	    = generic_delete_inode,
	.delete_inode	= cifs_delete_inode,  */  /* Do not need above two
	functions unless later we add lazy close of inodes or unless the
	kernel forgets to call us with the same number of releases (closes)
	as opens */
L
Linus Torvalds 已提交
586
	.show_options = cifs_show_options,
S
Steve French 已提交
587
	.umount_begin   = cifs_umount_begin,
L
Linus Torvalds 已提交
588
	.remount_fs = cifs_remount,
589
#ifdef CONFIG_CIFS_STATS2
590
	.show_stats = cifs_show_stats,
591
#endif
L
Linus Torvalds 已提交
592 593
};

594
static int
L
Linus Torvalds 已提交
595
cifs_get_sb(struct file_system_type *fs_type,
596
	    int flags, const char *dev_name, void *data, struct vfsmount *mnt)
L
Linus Torvalds 已提交
597 598 599 600 601 602 603
{
	int rc;
	struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);

	cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));

	if (IS_ERR(sb))
604
		return PTR_ERR(sb);
L
Linus Torvalds 已提交
605 606 607

	sb->s_flags = flags;

608
	rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
L
Linus Torvalds 已提交
609
	if (rc) {
610
		deactivate_locked_super(sb);
611
		return rc;
L
Linus Torvalds 已提交
612 613
	}
	sb->s_flags |= MS_ACTIVE;
614 615
	simple_set_mnt(mnt, sb);
	return 0;
L
Linus Torvalds 已提交
616 617
}

618 619
static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
				   unsigned long nr_segs, loff_t pos)
L
Linus Torvalds 已提交
620
{
621
	struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
L
Linus Torvalds 已提交
622 623
	ssize_t written;

624
	written = generic_file_aio_write(iocb, iov, nr_segs, pos);
625 626
	if (!CIFS_I(inode)->clientCanCacheAll)
		filemap_fdatawrite(inode->i_mapping);
L
Linus Torvalds 已提交
627 628 629
	return written;
}

630 631 632
static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
{
	/* origin == SEEK_END => we must revalidate the cached file length */
633
	if (origin == SEEK_END) {
634 635 636 637 638
		int retval;

		/* some applications poll for the file length in this strange
		   way so we must seek to end on non-oplocked files by
		   setting the revalidate time to zero */
639
		CIFS_I(file->f_path.dentry->d_inode)->time = 0;
640 641

		retval = cifs_revalidate(file->f_path.dentry);
642 643 644
		if (retval < 0)
			return (loff_t)retval;
	}
A
Andi Kleen 已提交
645
	return generic_file_llseek_unlocked(file, offset, origin);
646 647
}

S
Steve French 已提交
648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678
#ifdef CONFIG_CIFS_EXPERIMENTAL
static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
{
	/* note that this is called by vfs setlease with the BKL held
	   although I doubt that BKL is needed here in cifs */
	struct inode *inode = file->f_path.dentry->d_inode;

	if (!(S_ISREG(inode->i_mode)))
		return -EINVAL;

	/* check if file is oplocked */
	if (((arg == F_RDLCK) &&
		(CIFS_I(inode)->clientCanCacheRead)) ||
	    ((arg == F_WRLCK) &&
		(CIFS_I(inode)->clientCanCacheAll)))
		return generic_setlease(file, arg, lease);
	else if (CIFS_SB(inode->i_sb)->tcon->local_lease &&
			!CIFS_I(inode)->clientCanCacheRead)
		/* If the server claims to support oplock on this
		   file, then we still need to check oplock even
		   if the local_lease mount option is set, but there
		   are servers which do not support oplock for which
		   this mount option may be useful if the user
		   knows that the file won't be changed on the server
		   by anyone else */
		return generic_setlease(file, arg, lease);
	else
		return -EAGAIN;
}
#endif

679
struct file_system_type cifs_fs_type = {
L
Linus Torvalds 已提交
680 681 682 683 684 685
	.owner = THIS_MODULE,
	.name = "cifs",
	.get_sb = cifs_get_sb,
	.kill_sb = kill_anon_super,
	/*  .fs_flags */
};
686
const struct inode_operations cifs_dir_inode_ops = {
L
Linus Torvalds 已提交
687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707
	.create = cifs_create,
	.lookup = cifs_lookup,
	.getattr = cifs_getattr,
	.unlink = cifs_unlink,
	.link = cifs_hardlink,
	.mkdir = cifs_mkdir,
	.rmdir = cifs_rmdir,
	.rename = cifs_rename,
	.permission = cifs_permission,
/*	revalidate:cifs_revalidate,   */
	.setattr = cifs_setattr,
	.symlink = cifs_symlink,
	.mknod   = cifs_mknod,
#ifdef CONFIG_CIFS_XATTR
	.setxattr = cifs_setxattr,
	.getxattr = cifs_getxattr,
	.listxattr = cifs_listxattr,
	.removexattr = cifs_removexattr,
#endif
};

708
const struct inode_operations cifs_file_inode_ops = {
L
Linus Torvalds 已提交
709 710 711 712 713 714 715 716 717 718
/*	revalidate:cifs_revalidate, */
	.setattr = cifs_setattr,
	.getattr = cifs_getattr, /* do we need this anymore? */
	.rename = cifs_rename,
	.permission = cifs_permission,
#ifdef CONFIG_CIFS_XATTR
	.setxattr = cifs_setxattr,
	.getxattr = cifs_getxattr,
	.listxattr = cifs_listxattr,
	.removexattr = cifs_removexattr,
719
#endif
L
Linus Torvalds 已提交
720 721
};

722
const struct inode_operations cifs_symlink_inode_ops = {
723
	.readlink = generic_readlink,
L
Linus Torvalds 已提交
724 725 726 727 728 729 730 731 732 733 734
	.follow_link = cifs_follow_link,
	.put_link = cifs_put_link,
	.permission = cifs_permission,
	/* BB add the following two eventually */
	/* revalidate: cifs_revalidate,
	   setattr:    cifs_notify_change, *//* BB do we need notify change */
#ifdef CONFIG_CIFS_XATTR
	.setxattr = cifs_setxattr,
	.getxattr = cifs_getxattr,
	.listxattr = cifs_listxattr,
	.removexattr = cifs_removexattr,
735
#endif
L
Linus Torvalds 已提交
736 737
};

738
const struct file_operations cifs_file_ops = {
739 740 741 742
	.read = do_sync_read,
	.write = do_sync_write,
	.aio_read = generic_file_aio_read,
	.aio_write = cifs_file_aio_write,
L
Linus Torvalds 已提交
743 744 745 746 747 748
	.open = cifs_open,
	.release = cifs_close,
	.lock = cifs_lock,
	.fsync = cifs_fsync,
	.flush = cifs_flush,
	.mmap  = cifs_file_mmap,
749
	.splice_read = generic_file_splice_read,
750
	.llseek = cifs_llseek,
751
#ifdef CONFIG_CIFS_POSIX
752
	.unlocked_ioctl	= cifs_ioctl,
753 754
#endif /* CONFIG_CIFS_POSIX */

L
Linus Torvalds 已提交
755
#ifdef CONFIG_CIFS_EXPERIMENTAL
S
Steve French 已提交
756
	.setlease = cifs_setlease,
L
Linus Torvalds 已提交
757 758 759
#endif /* CONFIG_CIFS_EXPERIMENTAL */
};

760
const struct file_operations cifs_file_direct_ops = {
761
	/* no mmap, no aio, no readv -
L
Linus Torvalds 已提交
762 763 764 765 766 767 768 769
	   BB reevaluate whether they can be done with directio, no cache */
	.read = cifs_user_read,
	.write = cifs_user_write,
	.open = cifs_open,
	.release = cifs_close,
	.lock = cifs_lock,
	.fsync = cifs_fsync,
	.flush = cifs_flush,
770
	.splice_read = generic_file_splice_read,
771
#ifdef CONFIG_CIFS_POSIX
772
	.unlocked_ioctl  = cifs_ioctl,
773
#endif /* CONFIG_CIFS_POSIX */
774
	.llseek = cifs_llseek,
L
Linus Torvalds 已提交
775
#ifdef CONFIG_CIFS_EXPERIMENTAL
S
Steve French 已提交
776
	.setlease = cifs_setlease,
L
Linus Torvalds 已提交
777 778
#endif /* CONFIG_CIFS_EXPERIMENTAL */
};
779
const struct file_operations cifs_file_nobrl_ops = {
780 781 782 783 784 785 786 787 788
	.read = do_sync_read,
	.write = do_sync_write,
	.aio_read = generic_file_aio_read,
	.aio_write = cifs_file_aio_write,
	.open = cifs_open,
	.release = cifs_close,
	.fsync = cifs_fsync,
	.flush = cifs_flush,
	.mmap  = cifs_file_mmap,
789
	.splice_read = generic_file_splice_read,
790
	.llseek = cifs_llseek,
791
#ifdef CONFIG_CIFS_POSIX
792
	.unlocked_ioctl	= cifs_ioctl,
793 794 795
#endif /* CONFIG_CIFS_POSIX */

#ifdef CONFIG_CIFS_EXPERIMENTAL
S
Steve French 已提交
796
	.setlease = cifs_setlease,
797 798 799
#endif /* CONFIG_CIFS_EXPERIMENTAL */
};

800
const struct file_operations cifs_file_direct_nobrl_ops = {
801
	/* no mmap, no aio, no readv -
802 803 804 805 806 807 808
	   BB reevaluate whether they can be done with directio, no cache */
	.read = cifs_user_read,
	.write = cifs_user_write,
	.open = cifs_open,
	.release = cifs_close,
	.fsync = cifs_fsync,
	.flush = cifs_flush,
809
	.splice_read = generic_file_splice_read,
810
#ifdef CONFIG_CIFS_POSIX
811
	.unlocked_ioctl  = cifs_ioctl,
812
#endif /* CONFIG_CIFS_POSIX */
813
	.llseek = cifs_llseek,
814
#ifdef CONFIG_CIFS_EXPERIMENTAL
S
Steve French 已提交
815
	.setlease = cifs_setlease,
816 817
#endif /* CONFIG_CIFS_EXPERIMENTAL */
};
L
Linus Torvalds 已提交
818

819
const struct file_operations cifs_dir_ops = {
L
Linus Torvalds 已提交
820 821 822
	.readdir = cifs_readdir,
	.release = cifs_closedir,
	.read    = generic_read_dir,
823
	.unlocked_ioctl  = cifs_ioctl,
824
	.llseek = generic_file_llseek,
L
Linus Torvalds 已提交
825 826 827
};

static void
828
cifs_init_once(void *inode)
L
Linus Torvalds 已提交
829 830 831
{
	struct cifsInodeInfo *cifsi = inode;

C
Christoph Lameter 已提交
832 833
	inode_init_once(&cifsi->vfs_inode);
	INIT_LIST_HEAD(&cifsi->lockList);
L
Linus Torvalds 已提交
834 835 836 837 838 839
}

static int
cifs_init_inodecache(void)
{
	cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
840
					      sizeof(struct cifsInodeInfo),
841 842
					      0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
843
					      cifs_init_once);
L
Linus Torvalds 已提交
844 845 846 847 848 849 850 851 852
	if (cifs_inode_cachep == NULL)
		return -ENOMEM;

	return 0;
}

static void
cifs_destroy_inodecache(void)
{
853
	kmem_cache_destroy(cifs_inode_cachep);
L
Linus Torvalds 已提交
854 855 856 857 858
}

static int
cifs_init_request_bufs(void)
{
859
	if (CIFSMaxBufSize < 8192) {
L
Linus Torvalds 已提交
860 861 862 863 864 865 866 867 868 869 870 871
	/* Buffer size can not be smaller than 2 * PATH_MAX since maximum
	Unicode path name has to fit in any SMB/CIFS path based frames */
		CIFSMaxBufSize = 8192;
	} else if (CIFSMaxBufSize > 1024*127) {
		CIFSMaxBufSize = 1024 * 127;
	} else {
		CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
	}
/*	cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
	cifs_req_cachep = kmem_cache_create("cifs_request",
					    CIFSMaxBufSize +
					    MAX_CIFS_HDR_SIZE, 0,
872
					    SLAB_HWCACHE_ALIGN, NULL);
L
Linus Torvalds 已提交
873 874 875
	if (cifs_req_cachep == NULL)
		return -ENOMEM;

876
	if (cifs_min_rcv < 1)
L
Linus Torvalds 已提交
877 878 879
		cifs_min_rcv = 1;
	else if (cifs_min_rcv > 64) {
		cifs_min_rcv = 64;
880
		cERROR(1, ("cifs_min_rcv set to maximum (64)"));
L
Linus Torvalds 已提交
881 882
	}

883 884
	cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
						  cifs_req_cachep);
L
Linus Torvalds 已提交
885

886
	if (cifs_req_poolp == NULL) {
L
Linus Torvalds 已提交
887 888 889
		kmem_cache_destroy(cifs_req_cachep);
		return -ENOMEM;
	}
890
	/* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
L
Linus Torvalds 已提交
891 892
	almost all handle based requests (but not write response, nor is it
	sufficient for path based requests).  A smaller size would have
893
	been more efficient (compacting multiple slab items on one 4k page)
L
Linus Torvalds 已提交
894 895
	for the case in which debug was on, but this larger size allows
	more SMBs to use small buffer alloc and is still much more
S
Steve French 已提交
896
	efficient to alloc 1 per page off the slab compared to 17K (5page)
L
Linus Torvalds 已提交
897 898
	alloc of large cifs buffers even when page debugging is on */
	cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
S
Steve French 已提交
899
			MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
900
			NULL);
L
Linus Torvalds 已提交
901 902 903
	if (cifs_sm_req_cachep == NULL) {
		mempool_destroy(cifs_req_poolp);
		kmem_cache_destroy(cifs_req_cachep);
S
Steve French 已提交
904
		return -ENOMEM;
L
Linus Torvalds 已提交
905 906
	}

907
	if (cifs_min_small < 2)
L
Linus Torvalds 已提交
908 909 910
		cifs_min_small = 2;
	else if (cifs_min_small > 256) {
		cifs_min_small = 256;
S
Steve French 已提交
911
		cFYI(1, ("cifs_min_small set to maximum (256)"));
L
Linus Torvalds 已提交
912 913
	}

914 915
	cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
						     cifs_sm_req_cachep);
L
Linus Torvalds 已提交
916

917
	if (cifs_sm_req_poolp == NULL) {
L
Linus Torvalds 已提交
918 919 920 921 922 923 924 925 926 927 928 929 930
		mempool_destroy(cifs_req_poolp);
		kmem_cache_destroy(cifs_req_cachep);
		kmem_cache_destroy(cifs_sm_req_cachep);
		return -ENOMEM;
	}

	return 0;
}

static void
cifs_destroy_request_bufs(void)
{
	mempool_destroy(cifs_req_poolp);
931
	kmem_cache_destroy(cifs_req_cachep);
L
Linus Torvalds 已提交
932
	mempool_destroy(cifs_sm_req_poolp);
933
	kmem_cache_destroy(cifs_sm_req_cachep);
L
Linus Torvalds 已提交
934 935 936 937 938 939
}

static int
cifs_init_mids(void)
{
	cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
940 941
					    sizeof(struct mid_q_entry), 0,
					    SLAB_HWCACHE_ALIGN, NULL);
L
Linus Torvalds 已提交
942 943 944
	if (cifs_mid_cachep == NULL)
		return -ENOMEM;

945 946
	/* 3 is a reasonable minimum number of simultaneous operations */
	cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
947
	if (cifs_mid_poolp == NULL) {
L
Linus Torvalds 已提交
948 949 950 951 952
		kmem_cache_destroy(cifs_mid_cachep);
		return -ENOMEM;
	}

	cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
953 954
					sizeof(struct oplock_q_entry), 0,
					SLAB_HWCACHE_ALIGN, NULL);
L
Linus Torvalds 已提交
955 956
	if (cifs_oplock_cachep == NULL) {
		mempool_destroy(cifs_mid_poolp);
957
		kmem_cache_destroy(cifs_mid_cachep);
L
Linus Torvalds 已提交
958 959 960 961 962 963 964 965 966 967
		return -ENOMEM;
	}

	return 0;
}

static void
cifs_destroy_mids(void)
{
	mempool_destroy(cifs_mid_poolp);
968 969
	kmem_cache_destroy(cifs_mid_cachep);
	kmem_cache_destroy(cifs_oplock_cachep);
L
Linus Torvalds 已提交
970 971 972 973 974 975 976
}

static int __init
init_cifs(void)
{
	int rc = 0;
	cifs_proc_init();
977
	INIT_LIST_HEAD(&cifs_tcp_ses_list);
978 979 980
#ifdef CONFIG_CIFS_EXPERIMENTAL
	INIT_LIST_HEAD(&GlobalDnotifyReqList);
	INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
S
Steve French 已提交
981
#endif
L
Linus Torvalds 已提交
982 983 984 985 986
/*
 *  Initialize Global counters
 */
	atomic_set(&sesInfoAllocCount, 0);
	atomic_set(&tconInfoAllocCount, 0);
S
Steve French 已提交
987
	atomic_set(&tcpSesAllocCount, 0);
L
Linus Torvalds 已提交
988 989 990 991
	atomic_set(&tcpSesReconnectCount, 0);
	atomic_set(&tconInfoReconnectCount, 0);

	atomic_set(&bufAllocCount, 0);
992 993 994 995 996 997
	atomic_set(&smBufAllocCount, 0);
#ifdef CONFIG_CIFS_STATS2
	atomic_set(&totBufAllocCount, 0);
	atomic_set(&totSmBufAllocCount, 0);
#endif /* CONFIG_CIFS_STATS2 */

L
Linus Torvalds 已提交
998 999 1000 1001
	atomic_set(&midCount, 0);
	GlobalCurrentXid = 0;
	GlobalTotalActiveXid = 0;
	GlobalMaxActiveXid = 0;
1002
	memset(Local_System_Name, 0, 15);
L
Linus Torvalds 已提交
1003
	rwlock_init(&GlobalSMBSeslock);
1004
	rwlock_init(&cifs_tcp_ses_lock);
L
Linus Torvalds 已提交
1005 1006
	spin_lock_init(&GlobalMid_Lock);

1007
	if (cifs_max_pending < 2) {
L
Linus Torvalds 已提交
1008
		cifs_max_pending = 2;
S
Steve French 已提交
1009
		cFYI(1, ("cifs_max_pending set to min of 2"));
1010
	} else if (cifs_max_pending > 256) {
L
Linus Torvalds 已提交
1011
		cifs_max_pending = 256;
S
Steve French 已提交
1012
		cFYI(1, ("cifs_max_pending set to max of 256"));
L
Linus Torvalds 已提交
1013 1014 1015
	}

	rc = cifs_init_inodecache();
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
	if (rc)
		goto out_clean_proc;

	rc = cifs_init_mids();
	if (rc)
		goto out_destroy_inodecache;

	rc = cifs_init_request_bufs();
	if (rc)
		goto out_destroy_mids;

	rc = register_filesystem(&cifs_fs_type);
	if (rc)
		goto out_destroy_request_bufs;
1030 1031 1032 1033
#ifdef CONFIG_CIFS_UPCALL
	rc = register_key_type(&cifs_spnego_key_type);
	if (rc)
		goto out_unregister_filesystem;
1034 1035 1036 1037 1038
#endif
#ifdef CONFIG_CIFS_DFS_UPCALL
	rc = register_key_type(&key_type_dns_resolver);
	if (rc)
		goto out_unregister_key_type;
1039
#endif
1040 1041 1042
	rc = slow_work_register_user();
	if (rc)
		goto out_unregister_resolver_key;
1043 1044 1045

	return 0;

1046
 out_unregister_resolver_key:
1047 1048
#ifdef CONFIG_CIFS_DFS_UPCALL
	unregister_key_type(&key_type_dns_resolver);
1049
 out_unregister_key_type:
1050
#endif
1051 1052
#ifdef CONFIG_CIFS_UPCALL
	unregister_key_type(&cifs_spnego_key_type);
1053
 out_unregister_filesystem:
1054
#endif
1055 1056 1057 1058 1059 1060 1061 1062
	unregister_filesystem(&cifs_fs_type);
 out_destroy_request_bufs:
	cifs_destroy_request_bufs();
 out_destroy_mids:
	cifs_destroy_mids();
 out_destroy_inodecache:
	cifs_destroy_inodecache();
 out_clean_proc:
L
Linus Torvalds 已提交
1063 1064 1065 1066 1067 1068 1069
	cifs_proc_clean();
	return rc;
}

static void __exit
exit_cifs(void)
{
1070
	cFYI(DBG2, ("exit_cifs"));
L
Linus Torvalds 已提交
1071
	cifs_proc_clean();
1072
#ifdef CONFIG_CIFS_DFS_UPCALL
1073
	cifs_dfs_release_automount_timer();
1074 1075
	unregister_key_type(&key_type_dns_resolver);
#endif
1076 1077
#ifdef CONFIG_CIFS_UPCALL
	unregister_key_type(&cifs_spnego_key_type);
L
Linus Torvalds 已提交
1078 1079 1080 1081 1082 1083 1084 1085
#endif
	unregister_filesystem(&cifs_fs_type);
	cifs_destroy_inodecache();
	cifs_destroy_mids();
	cifs_destroy_request_bufs();
}

MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
S
Steve French 已提交
1086
MODULE_LICENSE("GPL");	/* combination of LGPL + GPL source behaves as GPL */
L
Linus Torvalds 已提交
1087
MODULE_DESCRIPTION
1088 1089
    ("VFS to access servers complying with the SNIA CIFS Specification "
     "e.g. Samba and Windows");
L
Linus Torvalds 已提交
1090 1091 1092
MODULE_VERSION(CIFS_VERSION);
module_init(init_cifs)
module_exit(exit_cifs)