cifsfs.c 27.0 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 <net/ipv6.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 "cifs_spnego.h"
49
#include "fscache.h"
L
Linus Torvalds 已提交
50 51 52 53 54 55 56 57 58 59
#define CIFS_MAGIC_NUMBER 0xFF534D42	/* the first four bytes of SMB PDUs */

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;
60
unsigned int global_secflags = CIFSSEC_DEF;
61
/* unsigned int ntlmv2_support = 0; */
L
Linus Torvalds 已提交
62
unsigned int sign_CIFS_PDUs = 1;
63
static const struct super_operations cifs_super_ops;
L
Linus Torvalds 已提交
64 65
unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
module_param(CIFSMaxBufSize, int, 0);
66 67
MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
				 "Default: 16384 Range: 8192 to 130048");
L
Linus Torvalds 已提交
68 69
unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
module_param(cifs_min_rcv, int, 0);
70 71
MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
				"1 to 64");
L
Linus Torvalds 已提交
72 73
unsigned int cifs_min_small = 30;
module_param(cifs_min_small, int, 0);
74 75
MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
				 "Range: 2 to 256");
L
Linus Torvalds 已提交
76 77
unsigned int cifs_max_pending = CIFS_MAX_REQ;
module_param(cifs_max_pending, int, 0);
78 79
MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
				   "Default: 50 Range: 2 to 256");
L
Linus Torvalds 已提交
80 81 82 83 84

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

85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
void
cifs_sb_active(struct super_block *sb)
{
	struct cifs_sb_info *server = CIFS_SB(sb);

	if (atomic_inc_return(&server->active) == 1)
		atomic_inc(&sb->s_active);
}

void
cifs_sb_deactive(struct super_block *sb)
{
	struct cifs_sb_info *server = CIFS_SB(sb);

	if (atomic_dec_and_test(&server->active))
		deactivate_super(sb);
}

L
Linus Torvalds 已提交
103 104 105 106 107 108 109
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;
110

111 112
	/* BB should we make this contingent on mount parm? */
	sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
S
Steve French 已提交
113
	sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
L
Linus Torvalds 已提交
114
	cifs_sb = CIFS_SB(sb);
115
	if (cifs_sb == NULL)
L
Linus Torvalds 已提交
116 117
		return -ENOMEM;

118
	spin_lock_init(&cifs_sb->tlink_tree_lock);
J
Jeff Layton 已提交
119
	cifs_sb->tlink_tree = RB_ROOT;
120

121 122 123 124 125 126
	rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
	if (rc) {
		kfree(cifs_sb);
		return rc;
	}

127 128 129 130 131 132 133 134
#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?*/
135 136 137 138
	if (data) {
		int len = strlen(data);
		cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
		if (cifs_sb->mountdata == NULL) {
139
			bdi_destroy(&cifs_sb->bdi);
140 141 142 143 144 145
			kfree(sb->s_fs_info);
			sb->s_fs_info = NULL;
			return -ENOMEM;
		}
		strncpy(cifs_sb->mountdata, data, len + 1);
		cifs_sb->mountdata[len] = '\0';
146 147 148
	}
#endif

L
Linus Torvalds 已提交
149 150 151 152
	rc = cifs_mount(sb, cifs_sb, data, devname);

	if (rc) {
		if (!silent)
153
			cERROR(1, "cifs_mount failed w/return code = %d", rc);
L
Linus Torvalds 已提交
154 155 156 157 158
		goto out_mount_failed;
	}

	sb->s_magic = CIFS_MAGIC_NUMBER;
	sb->s_op = &cifs_super_ops;
159
	sb->s_bdi = &cifs_sb->bdi;
L
Linus Torvalds 已提交
160 161
	sb->s_blocksize = CIFS_MAX_MSGSIZE;
	sb->s_blocksize_bits = 14;	/* default 2**14 = CIFS_MAX_MSGSIZE */
162
	inode = cifs_root_iget(sb, ROOT_I);
L
Linus Torvalds 已提交
163

164 165 166
	if (IS_ERR(inode)) {
		rc = PTR_ERR(inode);
		inode = NULL;
L
Linus Torvalds 已提交
167 168 169 170 171 172 173 174 175
		goto out_no_root;
	}

	sb->s_root = d_alloc_root(inode);

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

177 178
#ifdef CONFIG_CIFS_EXPERIMENTAL
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
179
		cFYI(1, "export ops supported");
180 181 182
		sb->s_export_op = &cifs_export_ops;
	}
#endif /* EXPERIMENTAL */
L
Linus Torvalds 已提交
183 184 185 186

	return 0;

out_no_root:
187
	cERROR(1, "cifs_read_super: get root inode failed");
L
Linus Torvalds 已提交
188 189
	if (inode)
		iput(inode);
S
Steve French 已提交
190

191
	cifs_umount(sb, cifs_sb);
L
Linus Torvalds 已提交
192 193

out_mount_failed:
194
	if (cifs_sb) {
195 196 197 198 199 200
#ifdef CONFIG_CIFS_DFS_UPCALL
		if (cifs_sb->mountdata) {
			kfree(cifs_sb->mountdata);
			cifs_sb->mountdata = NULL;
		}
#endif
201
		unload_nls(cifs_sb->local_nls);
202
		bdi_destroy(&cifs_sb->bdi);
L
Linus Torvalds 已提交
203 204 205 206 207 208 209 210 211 212 213
		kfree(cifs_sb);
	}
	return rc;
}

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

214
	cFYI(1, "In cifs_put_super");
L
Linus Torvalds 已提交
215
	cifs_sb = CIFS_SB(sb);
216
	if (cifs_sb == NULL) {
217
		cFYI(1, "Empty cifs superblock info passed to unmount");
L
Linus Torvalds 已提交
218 219
		return;
	}
220

S
Steve French 已提交
221
	rc = cifs_umount(sb, cifs_sb);
S
Steve French 已提交
222
	if (rc)
223
		cERROR(1, "cifs_umount failed with return code %d", rc);
224 225 226 227 228 229 230
#ifdef CONFIG_CIFS_DFS_UPCALL
	if (cifs_sb->mountdata) {
		kfree(cifs_sb->mountdata);
		cifs_sb->mountdata = NULL;
	}
#endif

L
Linus Torvalds 已提交
231
	unload_nls(cifs_sb->local_nls);
232
	bdi_destroy(&cifs_sb->bdi);
L
Linus Torvalds 已提交
233 234 235 236
	kfree(cifs_sb);
}

static int
237
cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
L
Linus Torvalds 已提交
238
{
239
	struct super_block *sb = dentry->d_sb;
S
Steve French 已提交
240
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
241
	struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
242
	int rc = -EOPNOTSUPP;
S
Steve French 已提交
243
	int xid;
L
Linus Torvalds 已提交
244 245 246 247 248

	xid = GetXid();

	buf->f_type = CIFS_MAGIC_NUMBER;

S
Steve French 已提交
249 250 251 252 253 254 255 256
	/*
	 * 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 已提交
257 258 259
	buf->f_files = 0;	/* undefined */
	buf->f_ffree = 0;	/* unlimited */

S
Steve French 已提交
260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278
	/*
	 * 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
	 */
279
	if (rc)
S
Steve French 已提交
280 281
		rc = SMBOldQFSInfo(xid, tcon, buf);

L
Linus Torvalds 已提交
282
	FreeXid(xid);
S
Steve French 已提交
283
	return 0;
L
Linus Torvalds 已提交
284 285
}

286
static int cifs_permission(struct inode *inode, int mask)
L
Linus Torvalds 已提交
287 288 289 290 291
{
	struct cifs_sb_info *cifs_sb;

	cifs_sb = CIFS_SB(inode->i_sb);

292 293 294 295 296 297
	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
298
		on the client (above and beyond ACL on servers) for
L
Linus Torvalds 已提交
299
		servers which do not support setting and viewing mode bits,
300
		so allowing client to check permissions is useful */
L
Linus Torvalds 已提交
301 302 303
		return generic_permission(inode, mask, NULL);
}

304 305 306 307
static struct kmem_cache *cifs_inode_cachep;
static struct kmem_cache *cifs_req_cachep;
static struct kmem_cache *cifs_mid_cachep;
static struct kmem_cache *cifs_sm_req_cachep;
L
Linus Torvalds 已提交
308 309 310 311 312 313 314 315
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;
316
	cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
L
Linus Torvalds 已提交
317 318 319 320 321 322 323
	if (!cifs_inode)
		return NULL;
	cifs_inode->cifsAttrs = 0x20;	/* default */
	cifs_inode->time = 0;
	/* Until the file is open and we have gotten oplock
	info back from the server, can not assume caching of
	file data or metadata */
324 325
	cifs_inode->clientCanCacheRead = false;
	cifs_inode->clientCanCacheAll = false;
326
	cifs_inode->delete_pending = false;
327
	cifs_inode->invalid_mapping = false;
L
Linus Torvalds 已提交
328
	cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
329
	cifs_inode->server_eof = 0;
330

331 332 333
	/* 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 已提交
334 335 336 337 338 339 340 341 342 343
	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));
}

344
static void
345
cifs_evict_inode(struct inode *inode)
346
{
347 348
	truncate_inode_pages(&inode->i_data, 0);
	end_writeback(inode);
349 350 351
	cifs_fscache_release_inode_cookie(inode);
}

352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372
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 已提交
373 374 375 376 377 378 379 380
/*
 * 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)
{
381
	struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
382
	struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
383 384
	struct sockaddr *srcaddr;
	srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
385

386
	seq_printf(s, ",unc=%s", tcon->treeName);
387 388 389 390

	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
		seq_printf(s, ",multiuser");
	else if (tcon->ses->userName)
391
		seq_printf(s, ",username=%s", tcon->ses->userName);
392

393 394 395
	if (tcon->ses->domainName)
		seq_printf(s, ",domain=%s", tcon->ses->domainName);

396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
	if (srcaddr->sa_family != AF_UNSPEC) {
		struct sockaddr_in *saddr4;
		struct sockaddr_in6 *saddr6;
		saddr4 = (struct sockaddr_in *)srcaddr;
		saddr6 = (struct sockaddr_in6 *)srcaddr;
		if (srcaddr->sa_family == AF_INET6)
			seq_printf(s, ",srcaddr=%pI6c",
				   &saddr6->sin6_addr);
		else if (srcaddr->sa_family == AF_INET)
			seq_printf(s, ",srcaddr=%pI4",
				   &saddr4->sin_addr.s_addr);
		else
			seq_printf(s, ",srcaddr=BAD-AF:%i",
				   (int)(srcaddr->sa_family));
	}

412
	seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
413 414
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
		seq_printf(s, ",forceuid");
415 416
	else
		seq_printf(s, ",noforceuid");
417

418
	seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
419 420
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
		seq_printf(s, ",forcegid");
421 422
	else
		seq_printf(s, ",noforcegid");
423

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

426 427
	if (!tcon->unix_ext)
		seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
428 429
					   cifs_sb->mnt_file_mode,
					   cifs_sb->mnt_dir_mode);
430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
	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");
460 461
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
		seq_printf(s, ",mfsymlinks");
462 463 464 465

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

L
Linus Torvalds 已提交
466 467 468
	return 0;
}

469
static void cifs_umount_begin(struct super_block *sb)
470
{
471
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
472
	struct cifsTconInfo *tcon;
473

474
	if (cifs_sb == NULL)
475 476
		return;

477
	tcon = cifs_sb_master_tcon(cifs_sb);
478

479
	spin_lock(&cifs_tcp_ses_lock);
480 481 482 483
	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 */
484
		spin_unlock(&cifs_tcp_ses_lock);
485 486
		return;
	} else if (tcon->tc_count == 1)
487
		tcon->tidStatus = CifsExiting;
488
	spin_unlock(&cifs_tcp_ses_lock);
489

490
	/* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
S
Steve French 已提交
491
	/* cancel_notify_requests(tcon); */
492
	if (tcon->ses && tcon->ses->server) {
493
		cFYI(1, "wake up tasks now - umount begin not complete");
494
		wake_up_all(&tcon->ses->server->request_q);
495 496 497 498 499
		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);
500
	}
501 502 503 504

	return;
}

505 506 507 508 509 510 511 512
#ifdef CONFIG_CIFS_STATS2
static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
{
	/* BB FIXME */
	return 0;
}
#endif

L
Linus Torvalds 已提交
513 514 515 516 517 518
static int cifs_remount(struct super_block *sb, int *flags, char *data)
{
	*flags |= MS_NODIRATIME;
	return 0;
}

519
static int cifs_drop_inode(struct inode *inode)
520 521 522
{
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);

523 524 525
	/* no serverino => unconditional eviction */
	return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
		generic_drop_inode(inode);
526 527
}

528
static const struct super_operations cifs_super_ops = {
L
Linus Torvalds 已提交
529 530 531 532
	.put_super = cifs_put_super,
	.statfs = cifs_statfs,
	.alloc_inode = cifs_alloc_inode,
	.destroy_inode = cifs_destroy_inode,
533
	.drop_inode	= cifs_drop_inode,
534
	.evict_inode	= cifs_evict_inode,
535 536
/*	.delete_inode	= cifs_delete_inode,  */  /* Do not need above
	function unless later we add lazy close of inodes or unless the
537 538
	kernel forgets to call us with the same number of releases (closes)
	as opens */
L
Linus Torvalds 已提交
539
	.show_options = cifs_show_options,
S
Steve French 已提交
540
	.umount_begin   = cifs_umount_begin,
L
Linus Torvalds 已提交
541
	.remount_fs = cifs_remount,
542
#ifdef CONFIG_CIFS_STATS2
543
	.show_stats = cifs_show_stats,
544
#endif
L
Linus Torvalds 已提交
545 546
};

A
Al Viro 已提交
547 548 549
static struct dentry *
cifs_do_mount(struct file_system_type *fs_type,
	    int flags, const char *dev_name, void *data)
L
Linus Torvalds 已提交
550 551
{
	int rc;
552 553 554
	struct super_block *sb;

	sb = sget(fs_type, NULL, set_anon_super, NULL);
L
Linus Torvalds 已提交
555

556
	cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
L
Linus Torvalds 已提交
557

J
Jan Blunck 已提交
558
	if (IS_ERR(sb))
A
Al Viro 已提交
559
		return ERR_CAST(sb);
L
Linus Torvalds 已提交
560 561 562

	sb->s_flags = flags;

563
	rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
L
Linus Torvalds 已提交
564
	if (rc) {
565
		deactivate_locked_super(sb);
A
Al Viro 已提交
566
		return ERR_PTR(rc);
L
Linus Torvalds 已提交
567 568
	}
	sb->s_flags |= MS_ACTIVE;
A
Al Viro 已提交
569
	return dget(sb->s_root);
L
Linus Torvalds 已提交
570 571
}

572 573
static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
				   unsigned long nr_segs, loff_t pos)
L
Linus Torvalds 已提交
574
{
575
	struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
L
Linus Torvalds 已提交
576 577
	ssize_t written;

578
	written = generic_file_aio_write(iocb, iov, nr_segs, pos);
579 580
	if (!CIFS_I(inode)->clientCanCacheAll)
		filemap_fdatawrite(inode->i_mapping);
L
Linus Torvalds 已提交
581 582 583
	return written;
}

584 585 586
static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
{
	/* origin == SEEK_END => we must revalidate the cached file length */
587
	if (origin == SEEK_END) {
588 589 590 591 592
		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 */
593
		CIFS_I(file->f_path.dentry->d_inode)->time = 0;
594

J
Jeff Layton 已提交
595
		retval = cifs_revalidate_file(file);
596 597 598
		if (retval < 0)
			return (loff_t)retval;
	}
A
Andi Kleen 已提交
599
	return generic_file_llseek_unlocked(file, offset, origin);
600 601
}

S
Steve French 已提交
602 603
static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
{
604 605
	/* note that this is called by vfs setlease with lock_flocks held
	   to protect *lease from going away */
S
Steve French 已提交
606
	struct inode *inode = file->f_path.dentry->d_inode;
607
	struct cifsFileInfo *cfile = file->private_data;
S
Steve French 已提交
608 609 610 611 612 613 614 615 616 617

	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);
618 619
	else if (tlink_tcon(cfile->tlink)->local_lease &&
		 !CIFS_I(inode)->clientCanCacheRead)
S
Steve French 已提交
620 621 622 623 624 625 626 627
		/* 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);
628
	else
S
Steve French 已提交
629 630 631
		return -EAGAIN;
}

632
struct file_system_type cifs_fs_type = {
L
Linus Torvalds 已提交
633 634
	.owner = THIS_MODULE,
	.name = "cifs",
A
Al Viro 已提交
635
	.mount = cifs_do_mount,
L
Linus Torvalds 已提交
636 637 638
	.kill_sb = kill_anon_super,
	/*  .fs_flags */
};
639
const struct inode_operations cifs_dir_inode_ops = {
L
Linus Torvalds 已提交
640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660
	.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
};

661
const struct inode_operations cifs_file_inode_ops = {
L
Linus Torvalds 已提交
662 663 664 665 666 667 668 669 670 671
/*	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,
672
#endif
L
Linus Torvalds 已提交
673 674
};

675
const struct inode_operations cifs_symlink_inode_ops = {
676
	.readlink = generic_readlink,
L
Linus Torvalds 已提交
677 678 679 680 681 682 683 684 685 686 687
	.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,
688
#endif
L
Linus Torvalds 已提交
689 690
};

691
const struct file_operations cifs_file_ops = {
692 693 694 695
	.read = do_sync_read,
	.write = do_sync_write,
	.aio_read = generic_file_aio_read,
	.aio_write = cifs_file_aio_write,
L
Linus Torvalds 已提交
696 697 698 699 700 701
	.open = cifs_open,
	.release = cifs_close,
	.lock = cifs_lock,
	.fsync = cifs_fsync,
	.flush = cifs_flush,
	.mmap  = cifs_file_mmap,
702
	.splice_read = generic_file_splice_read,
703
	.llseek = cifs_llseek,
704
#ifdef CONFIG_CIFS_POSIX
705
	.unlocked_ioctl	= cifs_ioctl,
706
#endif /* CONFIG_CIFS_POSIX */
S
Steve French 已提交
707
	.setlease = cifs_setlease,
L
Linus Torvalds 已提交
708 709
};

710
const struct file_operations cifs_file_direct_ops = {
711
	/* no aio, no readv -
L
Linus Torvalds 已提交
712 713 714 715 716 717 718 719
	   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,
720
	.mmap = cifs_file_mmap,
721
	.splice_read = generic_file_splice_read,
722
#ifdef CONFIG_CIFS_POSIX
723
	.unlocked_ioctl  = cifs_ioctl,
724
#endif /* CONFIG_CIFS_POSIX */
725
	.llseek = cifs_llseek,
S
Steve French 已提交
726
	.setlease = cifs_setlease,
L
Linus Torvalds 已提交
727
};
728
const struct file_operations cifs_file_nobrl_ops = {
729 730 731 732 733 734 735 736 737
	.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,
738
	.splice_read = generic_file_splice_read,
739
	.llseek = cifs_llseek,
740
#ifdef CONFIG_CIFS_POSIX
741
	.unlocked_ioctl	= cifs_ioctl,
742
#endif /* CONFIG_CIFS_POSIX */
S
Steve French 已提交
743
	.setlease = cifs_setlease,
744 745
};

746
const struct file_operations cifs_file_direct_nobrl_ops = {
747
	/* no mmap, no aio, no readv -
748 749 750 751 752 753 754
	   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,
755
	.mmap = cifs_file_mmap,
756
	.splice_read = generic_file_splice_read,
757
#ifdef CONFIG_CIFS_POSIX
758
	.unlocked_ioctl  = cifs_ioctl,
759
#endif /* CONFIG_CIFS_POSIX */
760
	.llseek = cifs_llseek,
S
Steve French 已提交
761
	.setlease = cifs_setlease,
762
};
L
Linus Torvalds 已提交
763

764
const struct file_operations cifs_dir_ops = {
L
Linus Torvalds 已提交
765 766 767
	.readdir = cifs_readdir,
	.release = cifs_closedir,
	.read    = generic_read_dir,
768
	.unlocked_ioctl  = cifs_ioctl,
769
	.llseek = generic_file_llseek,
L
Linus Torvalds 已提交
770 771 772
};

static void
773
cifs_init_once(void *inode)
L
Linus Torvalds 已提交
774 775 776
{
	struct cifsInodeInfo *cifsi = inode;

C
Christoph Lameter 已提交
777 778
	inode_init_once(&cifsi->vfs_inode);
	INIT_LIST_HEAD(&cifsi->lockList);
L
Linus Torvalds 已提交
779 780 781 782 783 784
}

static int
cifs_init_inodecache(void)
{
	cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
785
					      sizeof(struct cifsInodeInfo),
786 787
					      0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
788
					      cifs_init_once);
L
Linus Torvalds 已提交
789 790 791 792 793 794 795 796 797
	if (cifs_inode_cachep == NULL)
		return -ENOMEM;

	return 0;
}

static void
cifs_destroy_inodecache(void)
{
798
	kmem_cache_destroy(cifs_inode_cachep);
L
Linus Torvalds 已提交
799 800 801 802 803
}

static int
cifs_init_request_bufs(void)
{
804
	if (CIFSMaxBufSize < 8192) {
L
Linus Torvalds 已提交
805 806 807 808 809 810 811 812
	/* 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*/
	}
813
/*	cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
L
Linus Torvalds 已提交
814 815 816
	cifs_req_cachep = kmem_cache_create("cifs_request",
					    CIFSMaxBufSize +
					    MAX_CIFS_HDR_SIZE, 0,
817
					    SLAB_HWCACHE_ALIGN, NULL);
L
Linus Torvalds 已提交
818 819 820
	if (cifs_req_cachep == NULL)
		return -ENOMEM;

821
	if (cifs_min_rcv < 1)
L
Linus Torvalds 已提交
822 823 824
		cifs_min_rcv = 1;
	else if (cifs_min_rcv > 64) {
		cifs_min_rcv = 64;
825
		cERROR(1, "cifs_min_rcv set to maximum (64)");
L
Linus Torvalds 已提交
826 827
	}

828 829
	cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
						  cifs_req_cachep);
L
Linus Torvalds 已提交
830

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

852
	if (cifs_min_small < 2)
L
Linus Torvalds 已提交
853 854 855
		cifs_min_small = 2;
	else if (cifs_min_small > 256) {
		cifs_min_small = 256;
856
		cFYI(1, "cifs_min_small set to maximum (256)");
L
Linus Torvalds 已提交
857 858
	}

859 860
	cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
						     cifs_sm_req_cachep);
L
Linus Torvalds 已提交
861

862
	if (cifs_sm_req_poolp == NULL) {
L
Linus Torvalds 已提交
863 864 865 866 867 868 869 870 871 872 873 874 875
		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);
876
	kmem_cache_destroy(cifs_req_cachep);
L
Linus Torvalds 已提交
877
	mempool_destroy(cifs_sm_req_poolp);
878
	kmem_cache_destroy(cifs_sm_req_cachep);
L
Linus Torvalds 已提交
879 880 881 882 883 884
}

static int
cifs_init_mids(void)
{
	cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
885 886
					    sizeof(struct mid_q_entry), 0,
					    SLAB_HWCACHE_ALIGN, NULL);
L
Linus Torvalds 已提交
887 888 889
	if (cifs_mid_cachep == NULL)
		return -ENOMEM;

890 891
	/* 3 is a reasonable minimum number of simultaneous operations */
	cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
892
	if (cifs_mid_poolp == NULL) {
L
Linus Torvalds 已提交
893 894 895 896 897 898 899 900 901 902 903
		kmem_cache_destroy(cifs_mid_cachep);
		return -ENOMEM;
	}

	return 0;
}

static void
cifs_destroy_mids(void)
{
	mempool_destroy(cifs_mid_poolp);
904
	kmem_cache_destroy(cifs_mid_cachep);
L
Linus Torvalds 已提交
905 906 907 908 909 910 911
}

static int __init
init_cifs(void)
{
	int rc = 0;
	cifs_proc_init();
912
	INIT_LIST_HEAD(&cifs_tcp_ses_list);
913 914 915
#ifdef CONFIG_CIFS_EXPERIMENTAL
	INIT_LIST_HEAD(&GlobalDnotifyReqList);
	INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
S
Steve French 已提交
916
#endif
L
Linus Torvalds 已提交
917 918 919 920 921
/*
 *  Initialize Global counters
 */
	atomic_set(&sesInfoAllocCount, 0);
	atomic_set(&tconInfoAllocCount, 0);
S
Steve French 已提交
922
	atomic_set(&tcpSesAllocCount, 0);
L
Linus Torvalds 已提交
923 924 925 926
	atomic_set(&tcpSesReconnectCount, 0);
	atomic_set(&tconInfoReconnectCount, 0);

	atomic_set(&bufAllocCount, 0);
927 928 929 930 931 932
	atomic_set(&smBufAllocCount, 0);
#ifdef CONFIG_CIFS_STATS2
	atomic_set(&totBufAllocCount, 0);
	atomic_set(&totSmBufAllocCount, 0);
#endif /* CONFIG_CIFS_STATS2 */

L
Linus Torvalds 已提交
933 934 935 936
	atomic_set(&midCount, 0);
	GlobalCurrentXid = 0;
	GlobalTotalActiveXid = 0;
	GlobalMaxActiveXid = 0;
937
	memset(Local_System_Name, 0, 15);
938
	spin_lock_init(&cifs_tcp_ses_lock);
939
	spin_lock_init(&cifs_file_list_lock);
L
Linus Torvalds 已提交
940 941
	spin_lock_init(&GlobalMid_Lock);

942
	if (cifs_max_pending < 2) {
L
Linus Torvalds 已提交
943
		cifs_max_pending = 2;
944
		cFYI(1, "cifs_max_pending set to min of 2");
945
	} else if (cifs_max_pending > 256) {
L
Linus Torvalds 已提交
946
		cifs_max_pending = 256;
947
		cFYI(1, "cifs_max_pending set to max of 256");
L
Linus Torvalds 已提交
948 949
	}

950 951
	rc = cifs_fscache_register();
	if (rc)
952
		goto out_clean_proc;
953

L
Linus Torvalds 已提交
954
	rc = cifs_init_inodecache();
955
	if (rc)
956
		goto out_unreg_fscache;
957 958 959 960 961 962 963 964 965 966 967 968

	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;
969 970 971 972
#ifdef CONFIG_CIFS_UPCALL
	rc = register_key_type(&cifs_spnego_key_type);
	if (rc)
		goto out_unregister_filesystem;
973
#endif
974 975 976

	return 0;

977
#ifdef CONFIG_CIFS_UPCALL
978
out_unregister_filesystem:
979
	unregister_filesystem(&cifs_fs_type);
980
#endif
981
out_destroy_request_bufs:
982
	cifs_destroy_request_bufs();
983
out_destroy_mids:
984
	cifs_destroy_mids();
985
out_destroy_inodecache:
986
	cifs_destroy_inodecache();
987
out_unreg_fscache:
988
	cifs_fscache_unregister();
989 990
out_clean_proc:
	cifs_proc_clean();
L
Linus Torvalds 已提交
991 992 993 994 995 996
	return rc;
}

static void __exit
exit_cifs(void)
{
997
	cFYI(DBG2, "exit_cifs");
L
Linus Torvalds 已提交
998
	cifs_proc_clean();
999
	cifs_fscache_unregister();
1000
#ifdef CONFIG_CIFS_DFS_UPCALL
1001
	cifs_dfs_release_automount_timer();
1002
#endif
1003 1004
#ifdef CONFIG_CIFS_UPCALL
	unregister_key_type(&cifs_spnego_key_type);
L
Linus Torvalds 已提交
1005 1006 1007 1008 1009 1010 1011 1012
#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 已提交
1013
MODULE_LICENSE("GPL");	/* combination of LGPL + GPL source behaves as GPL */
L
Linus Torvalds 已提交
1014
MODULE_DESCRIPTION
1015 1016
    ("VFS to access servers complying with the SNIA CIFS Specification "
     "e.g. Samba and Windows");
L
Linus Torvalds 已提交
1017 1018 1019
MODULE_VERSION(CIFS_VERSION);
module_init(init_cifs)
module_exit(exit_cifs)