cifsfs.c 30 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3
/*
 *   fs/cifs/cifsfs.c
 *
4
 *   Copyright (C) International Business Machines  Corp., 2002,2008
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
38 39 40 41 42 43 44 45
#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>
46
#include <linux/key-type.h>
47
#include "dns_resolve.h"
48
#include "cifs_spnego.h"
Linus Torvalds's avatar
Linus Torvalds committed
49 50 51 52
#define CIFS_MAGIC_NUMBER 0xFF534D42	/* the first four bytes of SMB PDUs */

#ifdef CONFIG_CIFS_QUOTA
static struct quotactl_ops cifs_quotactl_ops;
Steve French's avatar
Steve French committed
53 54
#endif /* QUOTA */

Linus Torvalds's avatar
Linus Torvalds committed
55 56 57 58 59 60 61 62
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;
63 64
unsigned int extended_security = CIFSSEC_DEF;
/* unsigned int ntlmv2_support = 0; */
Linus Torvalds's avatar
Linus Torvalds committed
65
unsigned int sign_CIFS_PDUs = 1;
Steve French's avatar
Steve French committed
66 67
extern struct task_struct *oplockThread; /* remove sparse warning */
struct task_struct *oplockThread = NULL;
68
/* extern struct task_struct * dnotifyThread; remove sparse warning */
Steve French's avatar
Steve French committed
69
static struct task_struct *dnotifyThread = NULL;
70
static const struct super_operations cifs_super_ops;
Linus Torvalds's avatar
Linus Torvalds committed
71 72
unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
module_param(CIFSMaxBufSize, int, 0);
73 74
MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
				 "Default: 16384 Range: 8192 to 130048");
Linus Torvalds's avatar
Linus Torvalds committed
75 76
unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
module_param(cifs_min_rcv, int, 0);
77 78
MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
				"1 to 64");
Linus Torvalds's avatar
Linus Torvalds committed
79 80
unsigned int cifs_min_small = 30;
module_param(cifs_min_small, int, 0);
81 82
MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
				 "Range: 2 to 256");
Linus Torvalds's avatar
Linus Torvalds committed
83 84
unsigned int cifs_max_pending = CIFS_MAX_REQ;
module_param(cifs_max_pending, int, 0);
85 86
MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
				   "Default: 50 Range: 2 to 256");
Linus Torvalds's avatar
Linus Torvalds committed
87 88 89 90 91

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

92
extern struct kmem_cache *cifs_oplock_cachep;
Linus Torvalds's avatar
Linus Torvalds committed
93 94 95 96 97 98 99 100

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;
101

102 103
	/* BB should we make this contingent on mount parm? */
	sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
104
	sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
105
	cifs_sb = CIFS_SB(sb);
106
	if (cifs_sb == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
107 108
		return -ENOMEM;

109 110 111 112 113 114 115 116
#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?*/
117 118 119 120 121 122 123 124 125 126
	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';
127 128 129
	}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
130 131 132 133 134 135 136 137 138 139 140
	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;
141
/*	if (cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
142 143
	    sb->s_blocksize =
		cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
Linus Torvalds's avatar
Linus Torvalds committed
144 145 146 147 148
#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 */
149
	inode = cifs_iget(sb, ROOT_I);
Linus Torvalds's avatar
Linus Torvalds committed
150

151 152 153
	if (IS_ERR(inode)) {
		rc = PTR_ERR(inode);
		inode = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
154 155 156 157 158 159 160 161 162
		goto out_no_root;
	}

	sb->s_root = d_alloc_root(inode);

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

164 165 166 167 168 169
#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 */
Linus Torvalds's avatar
Linus Torvalds committed
170 171 172 173 174 175 176

	return 0;

out_no_root:
	cERROR(1, ("cifs_read_super: get root inode failed"));
	if (inode)
		iput(inode);
177

178
	cifs_umount(sb, cifs_sb);
Linus Torvalds's avatar
Linus Torvalds committed
179 180

out_mount_failed:
181
	if (cifs_sb) {
182 183 184 185 186 187
#ifdef CONFIG_CIFS_DFS_UPCALL
		if (cifs_sb->mountdata) {
			kfree(cifs_sb->mountdata);
			cifs_sb->mountdata = NULL;
		}
#endif
188
		if (cifs_sb->local_nls)
189
			unload_nls(cifs_sb->local_nls);
Linus Torvalds's avatar
Linus Torvalds committed
190 191 192 193 194 195 196 197 198 199 200 201 202
		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);
203
	if (cifs_sb == NULL) {
204
		cFYI(1, ("Empty cifs superblock info passed to unmount"));
Linus Torvalds's avatar
Linus Torvalds committed
205 206
		return;
	}
207
	rc = cifs_umount(sb, cifs_sb);
208
	if (rc)
Linus Torvalds's avatar
Linus Torvalds committed
209
		cERROR(1, ("cifs_umount failed with return code %d", rc));
210 211 212 213 214 215 216
#ifdef CONFIG_CIFS_DFS_UPCALL
	if (cifs_sb->mountdata) {
		kfree(cifs_sb->mountdata);
		cifs_sb->mountdata = NULL;
	}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
217 218 219 220 221 222
	unload_nls(cifs_sb->local_nls);
	kfree(cifs_sb);
	return;
}

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

	xid = GetXid();

	buf->f_type = CIFS_MAGIC_NUMBER;

Steve French's avatar
Steve French committed
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;
Linus Torvalds's avatar
Linus Torvalds committed
243 244 245
	buf->f_files = 0;	/* undefined */
	buf->f_ffree = 0;	/* unlimited */

Steve French's avatar
Steve French committed
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)
Steve French's avatar
Steve French committed
266 267
		rc = SMBOldQFSInfo(xid, tcon, buf);

Linus Torvalds's avatar
Linus Torvalds committed
268
	FreeXid(xid);
Steve French's avatar
Steve French committed
269
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
270 271
}

272
static int cifs_permission(struct inode *inode, int mask)
Linus Torvalds's avatar
Linus Torvalds committed
273 274 275 276 277
{
	struct cifs_sb_info *cifs_sb;

	cifs_sb = CIFS_SB(inode->i_sb);

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

287 288 289 290 291
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;
Linus Torvalds's avatar
Linus Torvalds committed
292 293 294 295 296 297 298 299
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;
300
	cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
301 302 303 304 305
	if (!cifs_inode)
		return NULL;
	cifs_inode->cifsAttrs = 0x20;	/* default */
	atomic_set(&cifs_inode->inUse, 0);
	cifs_inode->time = 0;
306
	cifs_inode->write_behind_rc = 0;
Linus Torvalds's avatar
Linus Torvalds committed
307 308 309
	/* Until the file is open and we have gotten oplock
	info back from the server, can not assume caching of
	file data or metadata */
310 311
	cifs_inode->clientCanCacheRead = false;
	cifs_inode->clientCanCacheAll = false;
Linus Torvalds's avatar
Linus Torvalds committed
312
	cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
313

314 315 316
	/* 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;*/
Linus Torvalds's avatar
Linus Torvalds committed
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
	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));
}

/*
 * 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)
{
	struct cifs_sb_info *cifs_sb;

	cifs_sb = CIFS_SB(m->mnt_sb);

	if (cifs_sb) {
		if (cifs_sb->tcon) {
341
/* BB add prepath to mount options displayed */
Linus Torvalds's avatar
Linus Torvalds committed
342 343 344 345 346
			seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
			if (cifs_sb->tcon->ses) {
				if (cifs_sb->tcon->ses->userName)
					seq_printf(s, ",username=%s",
					   cifs_sb->tcon->ses->userName);
347
				if (cifs_sb->tcon->ses->domainName)
Linus Torvalds's avatar
Linus Torvalds committed
348 349 350
					seq_printf(s, ",domain=%s",
					   cifs_sb->tcon->ses->domainName);
			}
351 352 353 354 355 356
			if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) ||
			   !(cifs_sb->tcon->unix_ext))
				seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
			if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) ||
			   !(cifs_sb->tcon->unix_ext))
				seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
357 358 359 360 361 362 363
			if (!cifs_sb->tcon->unix_ext) {
				seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
					   cifs_sb->mnt_file_mode,
					   cifs_sb->mnt_dir_mode);
			}
			if (cifs_sb->tcon->seal)
				seq_printf(s, ",seal");
364
			if (cifs_sb->tcon->nocase)
365
				seq_printf(s, ",nocase");
366 367
			if (cifs_sb->tcon->retry)
				seq_printf(s, ",hard");
Linus Torvalds's avatar
Linus Torvalds committed
368
		}
369 370
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
			seq_printf(s, ",posixpaths");
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391
		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");

392 393
		seq_printf(s, ",rsize=%d", cifs_sb->rsize);
		seq_printf(s, ",wsize=%d", cifs_sb->wsize);
Linus Torvalds's avatar
Linus Torvalds committed
394 395 396 397 398
	}
	return 0;
}

#ifdef CONFIG_CIFS_QUOTA
399 400
int cifs_xquota_set(struct super_block *sb, int quota_type, qid_t qid,
		struct fs_disk_quota *pdquota)
Linus Torvalds's avatar
Linus Torvalds committed
401 402 403 404 405
{
	int xid;
	int rc = 0;
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
	struct cifsTconInfo *pTcon;
406

407
	if (cifs_sb)
Linus Torvalds's avatar
Linus Torvalds committed
408 409 410 411 412 413
		pTcon = cifs_sb->tcon;
	else
		return -EIO;


	xid = GetXid();
414
	if (pTcon) {
415
		cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
Linus Torvalds's avatar
Linus Torvalds committed
416
	} else {
417
		rc = -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
418 419 420 421 422 423
	}

	FreeXid(xid);
	return rc;
}

424 425
int cifs_xquota_get(struct super_block *sb, int quota_type, qid_t qid,
		    struct fs_disk_quota *pdquota)
Linus Torvalds's avatar
Linus Torvalds committed
426 427 428 429 430 431
{
	int xid;
	int rc = 0;
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
	struct cifsTconInfo *pTcon;

432
	if (cifs_sb)
Linus Torvalds's avatar
Linus Torvalds committed
433 434 435 436 437
		pTcon = cifs_sb->tcon;
	else
		return -EIO;

	xid = GetXid();
438
	if (pTcon) {
439
		cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
Linus Torvalds's avatar
Linus Torvalds committed
440 441 442 443 444 445 446 447
	} else {
		rc = -EIO;
	}

	FreeXid(xid);
	return rc;
}

448
int cifs_xstate_set(struct super_block *sb, unsigned int flags, int operation)
Linus Torvalds's avatar
Linus Torvalds committed
449
{
450
	int xid;
Linus Torvalds's avatar
Linus Torvalds committed
451 452 453 454
	int rc = 0;
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
	struct cifsTconInfo *pTcon;

455
	if (cifs_sb)
Linus Torvalds's avatar
Linus Torvalds committed
456 457 458 459 460
		pTcon = cifs_sb->tcon;
	else
		return -EIO;

	xid = GetXid();
461
	if (pTcon) {
462
		cFYI(1, ("flags: 0x%x operation: 0x%x", flags, operation));
Linus Torvalds's avatar
Linus Torvalds committed
463 464 465 466 467 468 469 470
	} else {
		rc = -EIO;
	}

	FreeXid(xid);
	return rc;
}

471
int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
Linus Torvalds's avatar
Linus Torvalds committed
472 473 474 475 476 477
{
	int xid;
	int rc = 0;
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
	struct cifsTconInfo *pTcon;

478
	if (cifs_sb) {
Linus Torvalds's avatar
Linus Torvalds committed
479 480 481 482 483
		pTcon = cifs_sb->tcon;
	} else {
		return -EIO;
	}
	xid = GetXid();
484
	if (pTcon) {
485
		cFYI(1, ("pqstats %p", qstats));
Linus Torvalds's avatar
Linus Torvalds committed
486 487 488 489 490 491 492 493 494 495
	} else {
		rc = -EIO;
	}

	FreeXid(xid);
	return rc;
}

static struct quotactl_ops cifs_quotactl_ops = {
	.set_xquota	= cifs_xquota_set,
496
	.get_xquota	= cifs_xquota_get,
Linus Torvalds's avatar
Linus Torvalds committed
497 498 499 500 501
	.set_xstate	= cifs_xstate_set,
	.get_xstate	= cifs_xstate_get,
};
#endif

502
static void cifs_umount_begin(struct super_block *sb)
503
{
504
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
505
	struct cifsTconInfo *tcon;
506

507
	if (cifs_sb == NULL)
508 509 510
		return;

	tcon = cifs_sb->tcon;
511
	if (tcon == NULL)
512
		return;
513 514 515 516 517
	down(&tcon->tconSem);
	if (atomic_read(&tcon->useCount) == 1)
		tcon->tidStatus = CifsExiting;
	up(&tcon->tconSem);

518
	/* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
Steve French's avatar
Steve French committed
519
	/* cancel_notify_requests(tcon); */
520 521
	if (tcon->ses && tcon->ses->server) {
		cFYI(1, ("wake up tasks now - umount begin not complete"));
522
		wake_up_all(&tcon->ses->server->request_q);
523 524 525 526 527
		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);
528 529
	}
/* BB FIXME - finish add checks for tidStatus BB */
530 531 532 533

	return;
}

534 535 536 537 538 539 540 541
#ifdef CONFIG_CIFS_STATS2
static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
{
	/* BB FIXME */
	return 0;
}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
542 543 544 545 546 547
static int cifs_remount(struct super_block *sb, int *flags, char *data)
{
	*flags |= MS_NODIRATIME;
	return 0;
}

548
static const struct super_operations cifs_super_ops = {
Linus Torvalds's avatar
Linus Torvalds committed
549 550 551 552
	.put_super = cifs_put_super,
	.statfs = cifs_statfs,
	.alloc_inode = cifs_alloc_inode,
	.destroy_inode = cifs_destroy_inode,
553 554 555 556 557
/*	.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 */
Linus Torvalds's avatar
Linus Torvalds committed
558
	.show_options = cifs_show_options,
Steve French's avatar
Steve French committed
559
	.umount_begin   = cifs_umount_begin,
Linus Torvalds's avatar
Linus Torvalds committed
560
	.remount_fs = cifs_remount,
561
#ifdef CONFIG_CIFS_STATS2
562
	.show_stats = cifs_show_stats,
563
#endif
Linus Torvalds's avatar
Linus Torvalds committed
564 565
};

566
static int
Linus Torvalds's avatar
Linus Torvalds committed
567
cifs_get_sb(struct file_system_type *fs_type,
568
	    int flags, const char *dev_name, void *data, struct vfsmount *mnt)
Linus Torvalds's avatar
Linus Torvalds committed
569 570 571 572 573 574 575
{
	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))
576
		return PTR_ERR(sb);
Linus Torvalds's avatar
Linus Torvalds committed
577 578 579

	sb->s_flags = flags;

580
	rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
Linus Torvalds's avatar
Linus Torvalds committed
581 582 583
	if (rc) {
		up_write(&sb->s_umount);
		deactivate_super(sb);
584
		return rc;
Linus Torvalds's avatar
Linus Torvalds committed
585 586
	}
	sb->s_flags |= MS_ACTIVE;
587
	return simple_set_mnt(mnt, sb);
Linus Torvalds's avatar
Linus Torvalds committed
588 589
}

590 591
static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
				   unsigned long nr_segs, loff_t pos)
Linus Torvalds's avatar
Linus Torvalds committed
592
{
593
	struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
Linus Torvalds's avatar
Linus Torvalds committed
594 595
	ssize_t written;

596
	written = generic_file_aio_write(iocb, iov, nr_segs, pos);
597 598
	if (!CIFS_I(inode)->clientCanCacheAll)
		filemap_fdatawrite(inode->i_mapping);
Linus Torvalds's avatar
Linus Torvalds committed
599 600 601
	return written;
}

602 603 604
static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
{
	/* origin == SEEK_END => we must revalidate the cached file length */
605
	if (origin == SEEK_END) {
606 607 608 609 610
		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 */
611
		CIFS_I(file->f_path.dentry->d_inode)->time = 0;
612 613

		retval = cifs_revalidate(file->f_path.dentry);
614 615 616
		if (retval < 0)
			return (loff_t)retval;
	}
617
	return generic_file_llseek_unlocked(file, offset, origin);
618 619
}

620
struct file_system_type cifs_fs_type = {
Linus Torvalds's avatar
Linus Torvalds committed
621 622 623 624 625 626
	.owner = THIS_MODULE,
	.name = "cifs",
	.get_sb = cifs_get_sb,
	.kill_sb = kill_anon_super,
	/*  .fs_flags */
};
627
const struct inode_operations cifs_dir_inode_ops = {
Linus Torvalds's avatar
Linus Torvalds committed
628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648
	.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
};

649
const struct inode_operations cifs_file_inode_ops = {
Linus Torvalds's avatar
Linus Torvalds committed
650 651 652 653 654 655 656 657 658 659
/*	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,
660
#endif
Linus Torvalds's avatar
Linus Torvalds committed
661 662
};

663
const struct inode_operations cifs_symlink_inode_ops = {
664
	.readlink = generic_readlink,
Linus Torvalds's avatar
Linus Torvalds committed
665 666 667 668 669 670 671 672 673 674 675
	.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,
676
#endif
Linus Torvalds's avatar
Linus Torvalds committed
677 678
};

679
const struct file_operations cifs_file_ops = {
680 681 682 683
	.read = do_sync_read,
	.write = do_sync_write,
	.aio_read = generic_file_aio_read,
	.aio_write = cifs_file_aio_write,
Linus Torvalds's avatar
Linus Torvalds committed
684 685 686 687 688 689
	.open = cifs_open,
	.release = cifs_close,
	.lock = cifs_lock,
	.fsync = cifs_fsync,
	.flush = cifs_flush,
	.mmap  = cifs_file_mmap,
690
	.splice_read = generic_file_splice_read,
691
	.llseek = cifs_llseek,
692
#ifdef CONFIG_CIFS_POSIX
693
	.unlocked_ioctl	= cifs_ioctl,
694 695
#endif /* CONFIG_CIFS_POSIX */

Linus Torvalds's avatar
Linus Torvalds committed
696 697 698 699 700
#ifdef CONFIG_CIFS_EXPERIMENTAL
	.dir_notify = cifs_dir_notify,
#endif /* CONFIG_CIFS_EXPERIMENTAL */
};

701
const struct file_operations cifs_file_direct_ops = {
702
	/* no mmap, no aio, no readv -
Linus Torvalds's avatar
Linus Torvalds committed
703 704 705 706 707 708 709 710
	   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,
711
	.splice_read = generic_file_splice_read,
712
#ifdef CONFIG_CIFS_POSIX
713
	.unlocked_ioctl  = cifs_ioctl,
714
#endif /* CONFIG_CIFS_POSIX */
715
	.llseek = cifs_llseek,
Linus Torvalds's avatar
Linus Torvalds committed
716 717 718 719
#ifdef CONFIG_CIFS_EXPERIMENTAL
	.dir_notify = cifs_dir_notify,
#endif /* CONFIG_CIFS_EXPERIMENTAL */
};
720
const struct file_operations cifs_file_nobrl_ops = {
721 722 723 724 725 726 727 728 729
	.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,
730
	.splice_read = generic_file_splice_read,
731
	.llseek = cifs_llseek,
732
#ifdef CONFIG_CIFS_POSIX
733
	.unlocked_ioctl	= cifs_ioctl,
734 735 736
#endif /* CONFIG_CIFS_POSIX */

#ifdef CONFIG_CIFS_EXPERIMENTAL
737
	.dir_notify = cifs_dir_notify,
738 739 740
#endif /* CONFIG_CIFS_EXPERIMENTAL */
};

741
const struct file_operations cifs_file_direct_nobrl_ops = {
742
	/* no mmap, no aio, no readv -
743 744 745 746 747 748 749
	   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,
750
	.splice_read = generic_file_splice_read,
751
#ifdef CONFIG_CIFS_POSIX
752
	.unlocked_ioctl  = cifs_ioctl,
753
#endif /* CONFIG_CIFS_POSIX */
754
	.llseek = cifs_llseek,
755
#ifdef CONFIG_CIFS_EXPERIMENTAL
756
	.dir_notify = cifs_dir_notify,
757 758
#endif /* CONFIG_CIFS_EXPERIMENTAL */
};
Linus Torvalds's avatar
Linus Torvalds committed
759

760
const struct file_operations cifs_dir_ops = {
Linus Torvalds's avatar
Linus Torvalds committed
761 762 763 764 765 766
	.readdir = cifs_readdir,
	.release = cifs_closedir,
	.read    = generic_read_dir,
#ifdef CONFIG_CIFS_EXPERIMENTAL
	.dir_notify = cifs_dir_notify,
#endif /* CONFIG_CIFS_EXPERIMENTAL */
767
	.unlocked_ioctl  = cifs_ioctl,
Linus Torvalds's avatar
Linus Torvalds committed
768 769 770
};

static void
771
cifs_init_once(void *inode)
Linus Torvalds's avatar
Linus Torvalds committed
772 773 774
{
	struct cifsInodeInfo *cifsi = inode;

775 776
	inode_init_once(&cifsi->vfs_inode);
	INIT_LIST_HEAD(&cifsi->lockList);
Linus Torvalds's avatar
Linus Torvalds committed
777 778 779 780 781 782
}

static int
cifs_init_inodecache(void)
{
	cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
783
					      sizeof(struct cifsInodeInfo),
784 785
					      0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
786
					      cifs_init_once);
Linus Torvalds's avatar
Linus Torvalds committed
787 788 789 790 791 792 793 794 795
	if (cifs_inode_cachep == NULL)
		return -ENOMEM;

	return 0;
}

static void
cifs_destroy_inodecache(void)
{
796
	kmem_cache_destroy(cifs_inode_cachep);
Linus Torvalds's avatar
Linus Torvalds committed
797 798 799 800 801
}

static int
cifs_init_request_bufs(void)
{
802
	if (CIFSMaxBufSize < 8192) {
Linus Torvalds's avatar
Linus Torvalds committed
803 804 805 806 807 808 809 810 811 812 813 814
	/* 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,
815
					    SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
816 817 818
	if (cifs_req_cachep == NULL)
		return -ENOMEM;

819
	if (cifs_min_rcv < 1)
Linus Torvalds's avatar
Linus Torvalds committed
820 821 822
		cifs_min_rcv = 1;
	else if (cifs_min_rcv > 64) {
		cifs_min_rcv = 64;
823
		cERROR(1, ("cifs_min_rcv set to maximum (64)"));
Linus Torvalds's avatar
Linus Torvalds committed
824 825
	}

826 827
	cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
						  cifs_req_cachep);
Linus Torvalds's avatar
Linus Torvalds committed
828

829
	if (cifs_req_poolp == NULL) {
Linus Torvalds's avatar
Linus Torvalds committed
830 831 832
		kmem_cache_destroy(cifs_req_cachep);
		return -ENOMEM;
	}
833
	/* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
Linus Torvalds's avatar
Linus Torvalds committed
834 835
	almost all handle based requests (but not write response, nor is it
	sufficient for path based requests).  A smaller size would have
836
	been more efficient (compacting multiple slab items on one 4k page)
Linus Torvalds's avatar
Linus Torvalds committed
837 838
	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
Steve French's avatar
Steve French committed
839
	efficient to alloc 1 per page off the slab compared to 17K (5page)
Linus Torvalds's avatar
Linus Torvalds committed
840 841
	alloc of large cifs buffers even when page debugging is on */
	cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
Steve French's avatar
Steve French committed
842
			MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
843
			NULL);
Linus Torvalds's avatar
Linus Torvalds committed
844 845 846
	if (cifs_sm_req_cachep == NULL) {
		mempool_destroy(cifs_req_poolp);
		kmem_cache_destroy(cifs_req_cachep);
Steve French's avatar
Steve French committed
847
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
848 849
	}

850
	if (cifs_min_small < 2)
Linus Torvalds's avatar
Linus Torvalds committed
851 852 853
		cifs_min_small = 2;
	else if (cifs_min_small > 256) {
		cifs_min_small = 256;
Steve French's avatar
Steve French committed
854
		cFYI(1, ("cifs_min_small set to maximum (256)"));
Linus Torvalds's avatar
Linus Torvalds committed
855 856
	}

857 858
	cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
						     cifs_sm_req_cachep);
Linus Torvalds's avatar
Linus Torvalds committed
859

860
	if (cifs_sm_req_poolp == NULL) {
Linus Torvalds's avatar
Linus Torvalds committed
861 862 863 864 865 866 867 868 869 870 871 872 873
		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);
874
	kmem_cache_destroy(cifs_req_cachep);
Linus Torvalds's avatar
Linus Torvalds committed
875
	mempool_destroy(cifs_sm_req_poolp);
876
	kmem_cache_destroy(cifs_sm_req_cachep);
Linus Torvalds's avatar
Linus Torvalds committed
877 878 879 880 881 882
}

static int
cifs_init_mids(void)
{
	cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
883 884
					    sizeof(struct mid_q_entry), 0,
					    SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
885 886 887
	if (cifs_mid_cachep == NULL)
		return -ENOMEM;

888 889
	/* 3 is a reasonable minimum number of simultaneous operations */
	cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
890
	if (cifs_mid_poolp == NULL) {
Linus Torvalds's avatar
Linus Torvalds committed
891 892 893 894 895
		kmem_cache_destroy(cifs_mid_cachep);
		return -ENOMEM;
	}

	cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
896 897
					sizeof(struct oplock_q_entry), 0,
					SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
898 899
	if (cifs_oplock_cachep == NULL) {
		mempool_destroy(cifs_mid_poolp);
900
		kmem_cache_destroy(cifs_mid_cachep);
Linus Torvalds's avatar
Linus Torvalds committed
901 902 903 904 905 906 907 908 909 910
		return -ENOMEM;
	}

	return 0;
}

static void
cifs_destroy_mids(void)
{
	mempool_destroy(cifs_mid_poolp);
911 912
	kmem_cache_destroy(cifs_mid_cachep);
	kmem_cache_destroy(cifs_oplock_cachep);
Linus Torvalds's avatar
Linus Torvalds committed
913 914
}

915
static int cifs_oplock_thread(void *dummyarg)
Linus Torvalds's avatar
Linus Torvalds committed
916
{
Steve French's avatar
Steve French committed
917
	struct oplock_q_entry *oplock_item;
Linus Torvalds's avatar
Linus Torvalds committed
918
	struct cifsTconInfo *pTcon;
Steve French's avatar
Steve French committed
919
	struct inode *inode;
Linus Torvalds's avatar
Linus Torvalds committed
920
	__u16  netfid;
921
	int rc, waitrc = 0;
Linus Torvalds's avatar
Linus Torvalds committed
922

923
	set_freezable();
Linus Torvalds's avatar
Linus Torvalds committed
924
	do {
Steve French's avatar
Steve French committed
925
		if (try_to_freeze())
926
			continue;
927

Linus Torvalds's avatar
Linus Torvalds committed
928
		spin_lock(&GlobalMid_Lock);
929
		if (list_empty(&GlobalOplock_Q)) {
Linus Torvalds's avatar
Linus Torvalds committed
930 931 932 933
			spin_unlock(&GlobalMid_Lock);
			set_current_state(TASK_INTERRUPTIBLE);
			schedule_timeout(39*HZ);
		} else {
Steve French's avatar
Steve French committed
934
			oplock_item = list_entry(GlobalOplock_Q.next,
935 936 937 938 939 940 941 942
						struct oplock_q_entry, qhead);
			cFYI(1, ("found oplock item to write out"));
			pTcon = oplock_item->tcon;
			inode = oplock_item->pinode;
			netfid = oplock_item->netfid;
			spin_unlock(&GlobalMid_Lock);
			DeleteOplockQEntry(oplock_item);
			/* can not grab inode sem here since it would
Steve French's avatar
Steve French committed
943
				deadlock when oplock received on delete
944
				since vfs_unlink holds the i_mutex across
Linus Torvalds's avatar
Linus Torvalds committed
945
				the call */
946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962
			/* mutex_lock(&inode->i_mutex);*/
			if (S_ISREG(inode->i_mode)) {
				rc = filemap_fdatawrite(inode->i_mapping);
				if (CIFS_I(inode)->clientCanCacheRead == 0) {
					waitrc = filemap_fdatawait(
							      inode->i_mapping);
					invalidate_remote_inode(inode);
				}
				if (rc == 0)
					rc = waitrc;
			} else
				rc = 0;
			/* mutex_unlock(&inode->i_mutex);*/
			if (rc)
				CIFS_I(inode)->write_behind_rc = rc;
			cFYI(1, ("Oplock flush inode %p rc %d",
				inode, rc));
Steve French's avatar
Steve French committed
963 964 965 966 967 968

				/* releasing stale oplock after recent reconnect
				of smb session using a now incorrect file
				handle is not a data integrity issue but do
				not bother sending an oplock release if session
				to server still is disconnected since oplock
Linus Torvalds's avatar
Linus Torvalds committed
969
				already released by the server in that case */
970 971 972 973 974 975 976
			if (pTcon->tidStatus != CifsNeedReconnect) {
				rc = CIFSSMBLock(0, pTcon, netfid,
						0 /* len */ , 0 /* offset */, 0,
						0, LOCKING_ANDX_OPLOCK_RELEASE,
						false /* wait flag */);
				cFYI(1, ("Oplock release rc = %d", rc));
			}
977 978
			set_current_state(TASK_INTERRUPTIBLE);
			schedule_timeout(1);  /* yield in case q were corrupt */
Linus Torvalds's avatar
Linus Torvalds committed
979
		}
980 981 982
	} while (!kthread_should_stop());

	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
983 984
}

985
static int cifs_dnotify_thread(void *dummyarg)
986
{
987 988 989
	struct list_head *tmp;
	struct cifsSesInfo *ses;

990
	do {
991
		if (try_to_freeze())
992
			continue;
993
		set_current_state(TASK_INTERRUPTIBLE);
994 995 996 997 998 999
		schedule_timeout(15*HZ);
		read_lock(&GlobalSMBSeslock);
		/* check if any stuck requests that need
		   to be woken up and wakeq so the
		   thread can wake up and error out */
		list_for_each(tmp, &GlobalSMBSessionList) {
Steve French's avatar
Steve French committed
1000
			ses = list_entry(tmp, struct cifsSesInfo,
1001
				cifsSessionList);
1002
			if (ses->server && atomic_read(&ses->server->inFlight))
1003 1004 1005
				wake_up_all(&ses->server->response_q);
		}
		read_unlock(&GlobalSMBSeslock);
1006 1007 1008
	} while (!kthread_should_stop());

	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1009 1010 1011 1012 1013 1014 1015
}

static int __init
init_cifs(void)
{
	int rc = 0;
	cifs_proc_init();
1016
/*	INIT_LIST_HEAD(&GlobalServerList);*/	/* BB not implemented yet */
Linus Torvalds's avatar
Linus Torvalds committed
1017 1018 1019
	INIT_LIST_HEAD(&GlobalSMBSessionList);
	INIT_LIST_HEAD(&GlobalTreeConnectionList);
	INIT_LIST_HEAD(&GlobalOplock_Q);
1020 1021 1022
#ifdef CONFIG_CIFS_EXPERIMENTAL
	INIT_LIST_HEAD(&GlobalDnotifyReqList);
	INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
Steve French's avatar
Steve French committed
1023
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1024 1025 1026 1027 1028
/*
 *  Initialize Global counters
 */
	atomic_set(&sesInfoAllocCount, 0);
	atomic_set(&tconInfoAllocCount, 0);
Steve French's avatar
Steve French committed
1029
	atomic_set(&tcpSesAllocCount, 0);
Linus Torvalds's avatar
Linus Torvalds committed
1030 1031 1032 1033
	atomic_set(&tcpSesReconnectCount, 0);
	atomic_set(&tconInfoReconnectCount, 0);

	atomic_set(&bufAllocCount, 0);
1034 1035 1036 1037 1038 1039
	atomic_set(&smBufAllocCount, 0);
#ifdef CONFIG_CIFS_STATS2
	atomic_set(&totBufAllocCount, 0);
	atomic_set(&totSmBufAllocCount, 0);
#endif /* CONFIG_CIFS_STATS2 */

Linus Torvalds's avatar
Linus Torvalds committed
1040 1041 1042 1043
	atomic_set(&midCount, 0);
	GlobalCurrentXid = 0;
	GlobalTotalActiveXid = 0;
	GlobalMaxActiveXid = 0;
1044
	memset(Local_System_Name, 0, 15);
Linus Torvalds's avatar
Linus Torvalds committed
1045 1046 1047
	rwlock_init(&GlobalSMBSeslock);
	spin_lock_init(&GlobalMid_Lock);

1048
	if (cifs_max_pending < 2) {
Linus Torvalds's avatar
Linus Torvalds committed
1049
		cifs_max_pending = 2;
Steve French's avatar
Steve French committed
1050
		cFYI(1, ("cifs_max_pending set to min of 2"));
1051
	} else if (cifs_max_pending > 256) {
Linus Torvalds's avatar
Linus Torvalds committed
1052
		cifs_max_pending = 256;
Steve French's avatar
Steve French committed
1053
		cFYI(1, ("cifs_max_pending set to max of 256"));
Linus Torvalds's avatar
Linus Torvalds committed
1054 1055 1056
	}

	rc = cifs_init_inodecache();
1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070
	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;
1071 1072 1073 1074
#ifdef CONFIG_CIFS_UPCALL
	rc = register_key_type(&cifs_spnego_key_type);
	if (rc)
		goto out_unregister_filesystem;
1075 1076 1077 1078 1079
#endif
#ifdef CONFIG_CIFS_DFS_UPCALL
	rc = register_key_type(&key_type_dns_resolver);
	if (rc)
		goto out_unregister_key_type;
1080
#endif
1081 1082 1083
	oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
	if (IS_ERR(oplockThread)) {
		rc = PTR_ERR(oplockThread);
Steve French's avatar
Steve French committed
1084
		cERROR(1, ("error %d create oplock thread", rc));
1085
		goto out_unregister_dfs_key_type;
Linus Torvalds's avatar
Linus Torvalds committed
1086
	}
1087 1088 1089 1090

	dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
	if (IS_ERR(dnotifyThread)) {
		rc = PTR_ERR(dnotifyThread);
Steve French's avatar
Steve French committed
1091
		cERROR(1, ("error %d create dnotify thread", rc));
1092 1093 1094 1095 1096 1097 1098
		goto out_stop_oplock_thread;
	}

	return 0;

 out_stop_oplock_thread:
	kthread_stop(oplockThread);
1099 1100 1101
 out_unregister_dfs_key_type:
#ifdef CONFIG_CIFS_DFS_UPCALL
	unregister_key_type(&key_type_dns_resolver);
1102
 out_unregister_key_type:
1103
#endif
1104 1105
#ifdef CONFIG_CIFS_UPCALL
	unregister_key_type(&cifs_spnego_key_type);
1106
 out_unregister_filesystem:
1107
#endif
1108 1109 1110 1111 1112 1113 1114 1115
	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:
Linus Torvalds's avatar
Linus Torvalds committed
1116 1117 1118 1119 1120 1121 1122
	cifs_proc_clean();
	return rc;
}

static void __exit
exit_cifs(void)
{
1123
	cFYI(DBG2, ("exit_cifs"));
Linus Torvalds's avatar
Linus Torvalds committed
1124
	cifs_proc_clean();
1125
#ifdef CONFIG_CIFS_DFS_UPCALL
1126
	cifs_dfs_release_automount_timer();
1127 1128
	unregister_key_type(&key_type_dns_resolver);
#endif
1129 1130
#ifdef CONFIG_CIFS_UPCALL
	unregister_key_type(&cifs_spnego_key_type);
Linus Torvalds's avatar
Linus Torvalds committed
1131 1132 1133 1134 1135
#endif
	unregister_filesystem(&cifs_fs_type);
	cifs_destroy_inodecache();
	cifs_destroy_mids();
	cifs_destroy_request_bufs();
1136 1137
	kthread_stop(oplockThread);
	kthread_stop(dnotifyThread);
Linus Torvalds's avatar
Linus Torvalds committed
1138 1139 1140
}

MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
Steve French's avatar
Steve French committed
1141
MODULE_LICENSE("GPL");	/* combination of LGPL + GPL source behaves as GPL */
Linus Torvalds's avatar
Linus Torvalds committed
1142
MODULE_DESCRIPTION
1143 1144
    ("VFS to access servers complying with the SNIA CIFS Specification "
     "e.g. Samba and Windows");
Linus Torvalds's avatar
Linus Torvalds committed
1145 1146 1147
MODULE_VERSION(CIFS_VERSION);
module_init(init_cifs)
module_exit(exit_cifs)