]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - fs/cifs/cifsfs.c
fs: move bdev code out of buffer.c
[mirror_ubuntu-artful-kernel.git] / fs / cifs / cifsfs.c
CommitLineData
1da177e4
LT
1/*
2 * fs/cifs/cifsfs.c
3 *
2b280fab 4 * Copyright (C) International Business Machines Corp., 2002,2008
1da177e4
LT
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * Common Internet FileSystem (CIFS) client
8 *
9 * This library is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU Lesser General Public License as published
11 * by the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24/* Note that BB means BUGBUG (ie something to fix eventually) */
25
26#include <linux/module.h>
27#include <linux/fs.h>
28#include <linux/mount.h>
29#include <linux/slab.h>
30#include <linux/init.h>
31#include <linux/list.h>
32#include <linux/seq_file.h>
33#include <linux/vfs.h>
34#include <linux/mempool.h>
6ab16d24 35#include <linux/delay.h>
45af7a0f 36#include <linux/kthread.h>
7dfb7103 37#include <linux/freezer.h>
1da177e4
LT
38#include "cifsfs.h"
39#include "cifspdu.h"
40#define DECLARE_GLOBALS_HERE
41#include "cifsglob.h"
42#include "cifsproto.h"
43#include "cifs_debug.h"
44#include "cifs_fs_sb.h"
45#include <linux/mm.h>
84a15b93 46#include <linux/key-type.h>
6103335d 47#include "dns_resolve.h"
e545937a 48#include "cifs_spnego.h"
1da177e4
LT
49#define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
50
51#ifdef CONFIG_CIFS_QUOTA
52static struct quotactl_ops cifs_quotactl_ops;
35c11fdd
SF
53#endif /* QUOTA */
54
1da177e4
LT
55int cifsFYI = 0;
56int cifsERROR = 1;
57int traceSMB = 0;
58unsigned int oplockEnabled = 1;
59unsigned int experimEnabled = 0;
60unsigned int linuxExtEnabled = 1;
61unsigned int lookupCacheEnabled = 1;
62unsigned int multiuser_mount = 0;
3979877e
SF
63unsigned int extended_security = CIFSSEC_DEF;
64/* unsigned int ntlmv2_support = 0; */
1da177e4 65unsigned int sign_CIFS_PDUs = 1;
6dc0f87e
SF
66extern struct task_struct *oplockThread; /* remove sparse warning */
67struct task_struct *oplockThread = NULL;
99ee4dbd 68/* extern struct task_struct * dnotifyThread; remove sparse warning */
954d7a1c 69#ifdef CONFIG_CIFS_EXPERIMENTAL
6dc0f87e 70static struct task_struct *dnotifyThread = NULL;
954d7a1c 71#endif
ee9b6d61 72static const struct super_operations cifs_super_ops;
1da177e4
LT
73unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
74module_param(CIFSMaxBufSize, int, 0);
63135e08
SF
75MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
76 "Default: 16384 Range: 8192 to 130048");
1da177e4
LT
77unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
78module_param(cifs_min_rcv, int, 0);
63135e08
SF
79MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
80 "1 to 64");
1da177e4
LT
81unsigned int cifs_min_small = 30;
82module_param(cifs_min_small, int, 0);
63135e08
SF
83MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
84 "Range: 2 to 256");
1da177e4
LT
85unsigned int cifs_max_pending = CIFS_MAX_REQ;
86module_param(cifs_max_pending, int, 0);
63135e08
SF
87MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
88 "Default: 50 Range: 2 to 256");
1da177e4 89
1da177e4
LT
90extern mempool_t *cifs_sm_req_poolp;
91extern mempool_t *cifs_req_poolp;
92extern mempool_t *cifs_mid_poolp;
93
e18b890b 94extern struct kmem_cache *cifs_oplock_cachep;
1da177e4
LT
95
96static int
97cifs_read_super(struct super_block *sb, void *data,
98 const char *devname, int silent)
99{
100 struct inode *inode;
101 struct cifs_sb_info *cifs_sb;
102 int rc = 0;
50c2f753 103
1b2b2126
SF
104 /* BB should we make this contingent on mount parm? */
105 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
790fe579 106 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
1da177e4 107 cifs_sb = CIFS_SB(sb);
4523cc30 108 if (cifs_sb == NULL)
1da177e4 109 return -ENOMEM;
1da177e4 110
e6ab1582
IM
111#ifdef CONFIG_CIFS_DFS_UPCALL
112 /* copy mount params to sb for use in submounts */
113 /* BB: should we move this after the mount so we
114 * do not have to do the copy on failed mounts?
115 * BB: May be it is better to do simple copy before
116 * complex operation (mount), and in case of fail
117 * just exit instead of doing mount and attempting
118 * undo it if this copy fails?*/
79ee9a8b
SF
119 if (data) {
120 int len = strlen(data);
121 cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
122 if (cifs_sb->mountdata == NULL) {
123 kfree(sb->s_fs_info);
124 sb->s_fs_info = NULL;
125 return -ENOMEM;
126 }
127 strncpy(cifs_sb->mountdata, data, len + 1);
128 cifs_sb->mountdata[len] = '\0';
e6ab1582 129 }
e6ab1582
IM
130#endif
131
1da177e4
LT
132 rc = cifs_mount(sb, cifs_sb, data, devname);
133
134 if (rc) {
135 if (!silent)
136 cERROR(1,
137 ("cifs_mount failed w/return code = %d", rc));
138 goto out_mount_failed;
139 }
140
141 sb->s_magic = CIFS_MAGIC_NUMBER;
142 sb->s_op = &cifs_super_ops;
4523cc30 143/* if (cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
790fe579
SF
144 sb->s_blocksize =
145 cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
1da177e4
LT
146#ifdef CONFIG_CIFS_QUOTA
147 sb->s_qcop = &cifs_quotactl_ops;
148#endif
149 sb->s_blocksize = CIFS_MAX_MSGSIZE;
150 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
ce634ab2 151 inode = cifs_iget(sb, ROOT_I);
1da177e4 152
ce634ab2
DH
153 if (IS_ERR(inode)) {
154 rc = PTR_ERR(inode);
155 inode = NULL;
1da177e4
LT
156 goto out_no_root;
157 }
158
159 sb->s_root = d_alloc_root(inode);
160
161 if (!sb->s_root) {
162 rc = -ENOMEM;
163 goto out_no_root;
164 }
50c2f753 165
7521a3c5
SF
166#ifdef CONFIG_CIFS_EXPERIMENTAL
167 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
168 cFYI(1, ("export ops supported"));
169 sb->s_export_op = &cifs_export_ops;
170 }
171#endif /* EXPERIMENTAL */
1da177e4
LT
172
173 return 0;
174
175out_no_root:
176 cERROR(1, ("cifs_read_super: get root inode failed"));
177 if (inode)
178 iput(inode);
54b4602d 179
2c731afb 180 cifs_umount(sb, cifs_sb);
1da177e4
LT
181
182out_mount_failed:
4523cc30 183 if (cifs_sb) {
e6ab1582
IM
184#ifdef CONFIG_CIFS_DFS_UPCALL
185 if (cifs_sb->mountdata) {
186 kfree(cifs_sb->mountdata);
187 cifs_sb->mountdata = NULL;
188 }
189#endif
4523cc30 190 if (cifs_sb->local_nls)
50c2f753 191 unload_nls(cifs_sb->local_nls);
1da177e4
LT
192 kfree(cifs_sb);
193 }
194 return rc;
195}
196
197static void
198cifs_put_super(struct super_block *sb)
199{
200 int rc = 0;
201 struct cifs_sb_info *cifs_sb;
202
203 cFYI(1, ("In cifs_put_super"));
204 cifs_sb = CIFS_SB(sb);
4523cc30 205 if (cifs_sb == NULL) {
790fe579 206 cFYI(1, ("Empty cifs superblock info passed to unmount"));
1da177e4
LT
207 return;
208 }
790fe579 209 rc = cifs_umount(sb, cifs_sb);
ad7a2926 210 if (rc)
1da177e4 211 cERROR(1, ("cifs_umount failed with return code %d", rc));
e6ab1582
IM
212#ifdef CONFIG_CIFS_DFS_UPCALL
213 if (cifs_sb->mountdata) {
214 kfree(cifs_sb->mountdata);
215 cifs_sb->mountdata = NULL;
216 }
217#endif
218
1da177e4
LT
219 unload_nls(cifs_sb->local_nls);
220 kfree(cifs_sb);
221 return;
222}
223
224static int
726c3342 225cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
1da177e4 226{
726c3342 227 struct super_block *sb = dentry->d_sb;
39da9847
SF
228 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
229 struct cifsTconInfo *tcon = cifs_sb->tcon;
c81156dd 230 int rc = -EOPNOTSUPP;
39da9847 231 int xid;
1da177e4
LT
232
233 xid = GetXid();
234
1da177e4
LT
235 buf->f_type = CIFS_MAGIC_NUMBER;
236
39da9847
SF
237 /*
238 * PATH_MAX may be too long - it would presumably be total path,
239 * but note that some servers (includinng Samba 3) have a shorter
240 * maximum path.
241 *
242 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
243 */
244 buf->f_namelen = PATH_MAX;
1da177e4
LT
245 buf->f_files = 0; /* undefined */
246 buf->f_ffree = 0; /* unlimited */
247
39da9847
SF
248 /*
249 * We could add a second check for a QFS Unix capability bit
250 */
251 if ((tcon->ses->capabilities & CAP_UNIX) &&
252 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
253 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
254
255 /*
256 * Only need to call the old QFSInfo if failed on newer one,
257 * e.g. by OS/2.
258 **/
259 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
260 rc = CIFSSMBQFSInfo(xid, tcon, buf);
261
262 /*
263 * Some old Windows servers also do not support level 103, retry with
264 * older level one if old server failed the previous call or we
265 * bypassed it because we detected that this was an older LANMAN sess
266 */
4523cc30 267 if (rc)
39da9847
SF
268 rc = SMBOldQFSInfo(xid, tcon, buf);
269
1da177e4 270 FreeXid(xid);
39da9847 271 return 0;
1da177e4
LT
272}
273
e6305c43 274static int cifs_permission(struct inode *inode, int mask)
1da177e4
LT
275{
276 struct cifs_sb_info *cifs_sb;
277
278 cifs_sb = CIFS_SB(inode->i_sb);
279
f696a365
MS
280 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
281 if ((mask & MAY_EXEC) && !execute_ok(inode))
282 return -EACCES;
283 else
284 return 0;
285 } else /* file mode might have been restricted at mount time
50c2f753 286 on the client (above and beyond ACL on servers) for
1da177e4 287 servers which do not support setting and viewing mode bits,
50c2f753 288 so allowing client to check permissions is useful */
1da177e4
LT
289 return generic_permission(inode, mask, NULL);
290}
291
e18b890b
CL
292static struct kmem_cache *cifs_inode_cachep;
293static struct kmem_cache *cifs_req_cachep;
294static struct kmem_cache *cifs_mid_cachep;
295struct kmem_cache *cifs_oplock_cachep;
296static struct kmem_cache *cifs_sm_req_cachep;
1da177e4
LT
297mempool_t *cifs_sm_req_poolp;
298mempool_t *cifs_req_poolp;
299mempool_t *cifs_mid_poolp;
300
301static struct inode *
302cifs_alloc_inode(struct super_block *sb)
303{
304 struct cifsInodeInfo *cifs_inode;
e94b1766 305 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
1da177e4
LT
306 if (!cifs_inode)
307 return NULL;
308 cifs_inode->cifsAttrs = 0x20; /* default */
309 atomic_set(&cifs_inode->inUse, 0);
310 cifs_inode->time = 0;
cea21805 311 cifs_inode->write_behind_rc = 0;
1da177e4
LT
312 /* Until the file is open and we have gotten oplock
313 info back from the server, can not assume caching of
314 file data or metadata */
4b18f2a9
SF
315 cifs_inode->clientCanCacheRead = false;
316 cifs_inode->clientCanCacheAll = false;
9a8165fc 317 cifs_inode->delete_pending = false;
1da177e4 318 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
50c2f753 319
1b2b2126
SF
320 /* Can not set i_flags here - they get immediately overwritten
321 to zero by the VFS */
322/* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
1da177e4
LT
323 INIT_LIST_HEAD(&cifs_inode->openFileList);
324 return &cifs_inode->vfs_inode;
325}
326
327static void
328cifs_destroy_inode(struct inode *inode)
329{
330 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
331}
332
333/*
334 * cifs_show_options() is for displaying mount options in /proc/mounts.
335 * Not all settable options are displayed but most of the important
336 * ones are.
337 */
338static int
339cifs_show_options(struct seq_file *s, struct vfsmount *m)
340{
341 struct cifs_sb_info *cifs_sb;
80909022
JL
342 struct cifsTconInfo *tcon;
343 struct TCP_Server_Info *server;
1da177e4
LT
344
345 cifs_sb = CIFS_SB(m->mnt_sb);
346
347 if (cifs_sb) {
80909022
JL
348 tcon = cifs_sb->tcon;
349 if (tcon) {
1da177e4 350 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
80909022
JL
351 if (tcon->ses) {
352 if (tcon->ses->userName)
1da177e4 353 seq_printf(s, ",username=%s",
80909022
JL
354 tcon->ses->userName);
355 if (tcon->ses->domainName)
1da177e4 356 seq_printf(s, ",domain=%s",
80909022
JL
357 tcon->ses->domainName);
358 server = tcon->ses->server;
359 if (server) {
360 seq_printf(s, ",addr=");
361 switch (server->addr.sockAddr6.
362 sin6_family) {
363 case AF_INET6:
bf66542b
SR
364 seq_printf(s, "%pI6",
365 &server->addr.sockAddr6.sin6_addr);
80909022
JL
366 break;
367 case AF_INET:
bf66542b
SR
368 seq_printf(s, "%pI4",
369 &server->addr.sockAddr.sin_addr.s_addr);
80909022
JL
370 break;
371 }
372 }
1da177e4 373 }
d5d18501 374 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) ||
80909022 375 !(tcon->unix_ext))
d5d18501
SF
376 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
377 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) ||
80909022 378 !(tcon->unix_ext))
d5d18501 379 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
80909022 380 if (!tcon->unix_ext) {
2b280fab
SF
381 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
382 cifs_sb->mnt_file_mode,
383 cifs_sb->mnt_dir_mode);
384 }
80909022 385 if (tcon->seal)
2b280fab 386 seq_printf(s, ",seal");
80909022 387 if (tcon->nocase)
2b280fab 388 seq_printf(s, ",nocase");
80909022 389 if (tcon->retry)
89562b77 390 seq_printf(s, ",hard");
1da177e4 391 }
80909022
JL
392 if (cifs_sb->prepath)
393 seq_printf(s, ",prepath=%s", cifs_sb->prepath);
4523cc30
SF
394 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
395 seq_printf(s, ",posixpaths");
2b280fab
SF
396 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
397 seq_printf(s, ",setuids");
398 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
399 seq_printf(s, ",serverino");
400 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
401 seq_printf(s, ",directio");
402 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
403 seq_printf(s, ",nouser_xattr");
404 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
405 seq_printf(s, ",mapchars");
406 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
407 seq_printf(s, ",sfu");
408 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
409 seq_printf(s, ",nobrl");
410 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
411 seq_printf(s, ",cifsacl");
412 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
413 seq_printf(s, ",dynperm");
414 if (m->mnt_sb->s_flags & MS_POSIXACL)
415 seq_printf(s, ",acl");
416
50c2f753
SF
417 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
418 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
1da177e4
LT
419 }
420 return 0;
421}
422
423#ifdef CONFIG_CIFS_QUOTA
50c2f753
SF
424int cifs_xquota_set(struct super_block *sb, int quota_type, qid_t qid,
425 struct fs_disk_quota *pdquota)
1da177e4
LT
426{
427 int xid;
428 int rc = 0;
429 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
430 struct cifsTconInfo *pTcon;
50c2f753 431
4523cc30 432 if (cifs_sb)
1da177e4
LT
433 pTcon = cifs_sb->tcon;
434 else
435 return -EIO;
436
437
438 xid = GetXid();
4523cc30 439 if (pTcon) {
50c2f753 440 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
61e74801 441 } else
95ba7362 442 rc = -EIO;
1da177e4
LT
443
444 FreeXid(xid);
445 return rc;
446}
447
50c2f753
SF
448int cifs_xquota_get(struct super_block *sb, int quota_type, qid_t qid,
449 struct fs_disk_quota *pdquota)
1da177e4
LT
450{
451 int xid;
452 int rc = 0;
453 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
454 struct cifsTconInfo *pTcon;
455
4523cc30 456 if (cifs_sb)
1da177e4
LT
457 pTcon = cifs_sb->tcon;
458 else
459 return -EIO;
460
461 xid = GetXid();
4523cc30 462 if (pTcon) {
50c2f753 463 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
61e74801 464 } else
1da177e4 465 rc = -EIO;
1da177e4
LT
466
467 FreeXid(xid);
468 return rc;
469}
470
50c2f753 471int cifs_xstate_set(struct super_block *sb, unsigned int flags, int operation)
1da177e4 472{
50c2f753 473 int xid;
1da177e4
LT
474 int rc = 0;
475 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
476 struct cifsTconInfo *pTcon;
477
4523cc30 478 if (cifs_sb)
1da177e4
LT
479 pTcon = cifs_sb->tcon;
480 else
481 return -EIO;
482
483 xid = GetXid();
4523cc30 484 if (pTcon) {
50c2f753 485 cFYI(1, ("flags: 0x%x operation: 0x%x", flags, operation));
61e74801 486 } else
1da177e4 487 rc = -EIO;
1da177e4
LT
488
489 FreeXid(xid);
490 return rc;
491}
492
50c2f753 493int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
1da177e4
LT
494{
495 int xid;
496 int rc = 0;
497 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
498 struct cifsTconInfo *pTcon;
499
61e74801 500 if (cifs_sb)
1da177e4 501 pTcon = cifs_sb->tcon;
61e74801 502 else
1da177e4 503 return -EIO;
61e74801 504
1da177e4 505 xid = GetXid();
4523cc30 506 if (pTcon) {
50c2f753 507 cFYI(1, ("pqstats %p", qstats));
61e74801 508 } else
1da177e4 509 rc = -EIO;
1da177e4
LT
510
511 FreeXid(xid);
512 return rc;
513}
514
515static struct quotactl_ops cifs_quotactl_ops = {
516 .set_xquota = cifs_xquota_set,
6f7e8f37 517 .get_xquota = cifs_xquota_get,
1da177e4
LT
518 .set_xstate = cifs_xstate_set,
519 .get_xstate = cifs_xstate_get,
520};
521#endif
522
42faad99 523static void cifs_umount_begin(struct super_block *sb)
68058e75 524{
42faad99 525 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
50c2f753 526 struct cifsTconInfo *tcon;
68058e75 527
4523cc30 528 if (cifs_sb == NULL)
9e2e85f8
SF
529 return;
530
531 tcon = cifs_sb->tcon;
4523cc30 532 if (tcon == NULL)
9e2e85f8 533 return;
f1987b44
JL
534
535 read_lock(&cifs_tcp_ses_lock);
536 if (tcon->tc_count == 1)
5e1253b5 537 tcon->tidStatus = CifsExiting;
f1987b44 538 read_unlock(&cifs_tcp_ses_lock);
5e1253b5 539
3a5ff61c 540 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
7b7abfe3 541 /* cancel_notify_requests(tcon); */
50c2f753
SF
542 if (tcon->ses && tcon->ses->server) {
543 cFYI(1, ("wake up tasks now - umount begin not complete"));
9e2e85f8 544 wake_up_all(&tcon->ses->server->request_q);
6ab16d24
SF
545 wake_up_all(&tcon->ses->server->response_q);
546 msleep(1); /* yield */
547 /* we have to kick the requests once more */
548 wake_up_all(&tcon->ses->server->response_q);
549 msleep(1);
5e1253b5
SF
550 }
551/* BB FIXME - finish add checks for tidStatus BB */
68058e75
SF
552
553 return;
554}
68058e75 555
bf97d287
SF
556#ifdef CONFIG_CIFS_STATS2
557static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
558{
559 /* BB FIXME */
560 return 0;
561}
562#endif
563
1da177e4
LT
564static int cifs_remount(struct super_block *sb, int *flags, char *data)
565{
566 *flags |= MS_NODIRATIME;
567 return 0;
568}
569
ee9b6d61 570static const struct super_operations cifs_super_ops = {
1da177e4
LT
571 .put_super = cifs_put_super,
572 .statfs = cifs_statfs,
573 .alloc_inode = cifs_alloc_inode,
574 .destroy_inode = cifs_destroy_inode,
50c2f753
SF
575/* .drop_inode = generic_delete_inode,
576 .delete_inode = cifs_delete_inode, */ /* Do not need above two
577 functions unless later we add lazy close of inodes or unless the
578 kernel forgets to call us with the same number of releases (closes)
579 as opens */
1da177e4 580 .show_options = cifs_show_options,
7b7abfe3 581 .umount_begin = cifs_umount_begin,
1da177e4 582 .remount_fs = cifs_remount,
bf97d287 583#ifdef CONFIG_CIFS_STATS2
f46d3e11 584 .show_stats = cifs_show_stats,
bf97d287 585#endif
1da177e4
LT
586};
587
454e2398 588static int
1da177e4 589cifs_get_sb(struct file_system_type *fs_type,
454e2398 590 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
1da177e4
LT
591{
592 int rc;
593 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
594
595 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
596
597 if (IS_ERR(sb))
454e2398 598 return PTR_ERR(sb);
1da177e4
LT
599
600 sb->s_flags = flags;
601
9b04c997 602 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
1da177e4
LT
603 if (rc) {
604 up_write(&sb->s_umount);
605 deactivate_super(sb);
454e2398 606 return rc;
1da177e4
LT
607 }
608 sb->s_flags |= MS_ACTIVE;
454e2398 609 return simple_set_mnt(mnt, sb);
1da177e4
LT
610}
611
027445c3
BP
612static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
613 unsigned long nr_segs, loff_t pos)
1da177e4 614{
e6a00296 615 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
1da177e4
LT
616 ssize_t written;
617
027445c3 618 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
87c89dd7
SF
619 if (!CIFS_I(inode)->clientCanCacheAll)
620 filemap_fdatawrite(inode->i_mapping);
1da177e4
LT
621 return written;
622}
623
c32a0b68
SF
624static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
625{
626 /* origin == SEEK_END => we must revalidate the cached file length */
0889a944 627 if (origin == SEEK_END) {
030e9d81
SF
628 int retval;
629
630 /* some applications poll for the file length in this strange
631 way so we must seek to end on non-oplocked files by
632 setting the revalidate time to zero */
c33f8d32 633 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
030e9d81
SF
634
635 retval = cifs_revalidate(file->f_path.dentry);
c32a0b68
SF
636 if (retval < 0)
637 return (loff_t)retval;
638 }
9465efc9 639 return generic_file_llseek_unlocked(file, offset, origin);
c32a0b68
SF
640}
641
84210e91
SF
642#ifdef CONFIG_CIFS_EXPERIMENTAL
643static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
644{
645 /* note that this is called by vfs setlease with the BKL held
646 although I doubt that BKL is needed here in cifs */
647 struct inode *inode = file->f_path.dentry->d_inode;
648
649 if (!(S_ISREG(inode->i_mode)))
650 return -EINVAL;
651
652 /* check if file is oplocked */
653 if (((arg == F_RDLCK) &&
654 (CIFS_I(inode)->clientCanCacheRead)) ||
655 ((arg == F_WRLCK) &&
656 (CIFS_I(inode)->clientCanCacheAll)))
657 return generic_setlease(file, arg, lease);
658 else if (CIFS_SB(inode->i_sb)->tcon->local_lease &&
659 !CIFS_I(inode)->clientCanCacheRead)
660 /* If the server claims to support oplock on this
661 file, then we still need to check oplock even
662 if the local_lease mount option is set, but there
663 are servers which do not support oplock for which
664 this mount option may be useful if the user
665 knows that the file won't be changed on the server
666 by anyone else */
667 return generic_setlease(file, arg, lease);
668 else
669 return -EAGAIN;
670}
671#endif
672
e6ab1582 673struct file_system_type cifs_fs_type = {
1da177e4
LT
674 .owner = THIS_MODULE,
675 .name = "cifs",
676 .get_sb = cifs_get_sb,
677 .kill_sb = kill_anon_super,
678 /* .fs_flags */
679};
754661f1 680const struct inode_operations cifs_dir_inode_ops = {
1da177e4
LT
681 .create = cifs_create,
682 .lookup = cifs_lookup,
683 .getattr = cifs_getattr,
684 .unlink = cifs_unlink,
685 .link = cifs_hardlink,
686 .mkdir = cifs_mkdir,
687 .rmdir = cifs_rmdir,
688 .rename = cifs_rename,
689 .permission = cifs_permission,
690/* revalidate:cifs_revalidate, */
691 .setattr = cifs_setattr,
692 .symlink = cifs_symlink,
693 .mknod = cifs_mknod,
694#ifdef CONFIG_CIFS_XATTR
695 .setxattr = cifs_setxattr,
696 .getxattr = cifs_getxattr,
697 .listxattr = cifs_listxattr,
698 .removexattr = cifs_removexattr,
699#endif
700};
701
754661f1 702const struct inode_operations cifs_file_inode_ops = {
1da177e4
LT
703/* revalidate:cifs_revalidate, */
704 .setattr = cifs_setattr,
705 .getattr = cifs_getattr, /* do we need this anymore? */
706 .rename = cifs_rename,
707 .permission = cifs_permission,
708#ifdef CONFIG_CIFS_XATTR
709 .setxattr = cifs_setxattr,
710 .getxattr = cifs_getxattr,
711 .listxattr = cifs_listxattr,
712 .removexattr = cifs_removexattr,
50c2f753 713#endif
1da177e4
LT
714};
715
754661f1 716const struct inode_operations cifs_symlink_inode_ops = {
50c2f753 717 .readlink = generic_readlink,
1da177e4
LT
718 .follow_link = cifs_follow_link,
719 .put_link = cifs_put_link,
720 .permission = cifs_permission,
721 /* BB add the following two eventually */
722 /* revalidate: cifs_revalidate,
723 setattr: cifs_notify_change, *//* BB do we need notify change */
724#ifdef CONFIG_CIFS_XATTR
725 .setxattr = cifs_setxattr,
726 .getxattr = cifs_getxattr,
727 .listxattr = cifs_listxattr,
728 .removexattr = cifs_removexattr,
50c2f753 729#endif
1da177e4
LT
730};
731
4b6f5d20 732const struct file_operations cifs_file_ops = {
87c89dd7
SF
733 .read = do_sync_read,
734 .write = do_sync_write,
87c89dd7
SF
735 .aio_read = generic_file_aio_read,
736 .aio_write = cifs_file_aio_write,
1da177e4
LT
737 .open = cifs_open,
738 .release = cifs_close,
739 .lock = cifs_lock,
740 .fsync = cifs_fsync,
741 .flush = cifs_flush,
742 .mmap = cifs_file_mmap,
5ffc4ef4 743 .splice_read = generic_file_splice_read,
c32a0b68 744 .llseek = cifs_llseek,
c67593a0 745#ifdef CONFIG_CIFS_POSIX
f9ddcca4 746 .unlocked_ioctl = cifs_ioctl,
c67593a0
SF
747#endif /* CONFIG_CIFS_POSIX */
748
1da177e4 749#ifdef CONFIG_CIFS_EXPERIMENTAL
84210e91 750 .setlease = cifs_setlease,
1da177e4
LT
751#endif /* CONFIG_CIFS_EXPERIMENTAL */
752};
753
4b6f5d20 754const struct file_operations cifs_file_direct_ops = {
50c2f753 755 /* no mmap, no aio, no readv -
1da177e4
LT
756 BB reevaluate whether they can be done with directio, no cache */
757 .read = cifs_user_read,
758 .write = cifs_user_write,
759 .open = cifs_open,
760 .release = cifs_close,
761 .lock = cifs_lock,
762 .fsync = cifs_fsync,
763 .flush = cifs_flush,
5ffc4ef4 764 .splice_read = generic_file_splice_read,
c67593a0 765#ifdef CONFIG_CIFS_POSIX
f9ddcca4 766 .unlocked_ioctl = cifs_ioctl,
c67593a0 767#endif /* CONFIG_CIFS_POSIX */
c32a0b68 768 .llseek = cifs_llseek,
1da177e4 769#ifdef CONFIG_CIFS_EXPERIMENTAL
84210e91 770 .setlease = cifs_setlease,
1da177e4
LT
771#endif /* CONFIG_CIFS_EXPERIMENTAL */
772};
4b6f5d20 773const struct file_operations cifs_file_nobrl_ops = {
87c89dd7
SF
774 .read = do_sync_read,
775 .write = do_sync_write,
87c89dd7
SF
776 .aio_read = generic_file_aio_read,
777 .aio_write = cifs_file_aio_write,
778 .open = cifs_open,
779 .release = cifs_close,
780 .fsync = cifs_fsync,
781 .flush = cifs_flush,
782 .mmap = cifs_file_mmap,
5ffc4ef4 783 .splice_read = generic_file_splice_read,
c32a0b68 784 .llseek = cifs_llseek,
8b94bcb9 785#ifdef CONFIG_CIFS_POSIX
f9ddcca4 786 .unlocked_ioctl = cifs_ioctl,
8b94bcb9
SF
787#endif /* CONFIG_CIFS_POSIX */
788
789#ifdef CONFIG_CIFS_EXPERIMENTAL
84210e91 790 .setlease = cifs_setlease,
8b94bcb9
SF
791#endif /* CONFIG_CIFS_EXPERIMENTAL */
792};
793
4b6f5d20 794const struct file_operations cifs_file_direct_nobrl_ops = {
50c2f753 795 /* no mmap, no aio, no readv -
87c89dd7
SF
796 BB reevaluate whether they can be done with directio, no cache */
797 .read = cifs_user_read,
798 .write = cifs_user_write,
799 .open = cifs_open,
800 .release = cifs_close,
801 .fsync = cifs_fsync,
802 .flush = cifs_flush,
5ffc4ef4 803 .splice_read = generic_file_splice_read,
8b94bcb9 804#ifdef CONFIG_CIFS_POSIX
f9ddcca4 805 .unlocked_ioctl = cifs_ioctl,
8b94bcb9 806#endif /* CONFIG_CIFS_POSIX */
c32a0b68 807 .llseek = cifs_llseek,
8b94bcb9 808#ifdef CONFIG_CIFS_EXPERIMENTAL
84210e91 809 .setlease = cifs_setlease,
8b94bcb9
SF
810#endif /* CONFIG_CIFS_EXPERIMENTAL */
811};
1da177e4 812
4b6f5d20 813const struct file_operations cifs_dir_ops = {
1da177e4
LT
814 .readdir = cifs_readdir,
815 .release = cifs_closedir,
816 .read = generic_read_dir,
f9ddcca4 817 .unlocked_ioctl = cifs_ioctl,
3222a3e5 818 .llseek = generic_file_llseek,
1da177e4
LT
819};
820
821static void
51cc5068 822cifs_init_once(void *inode)
1da177e4
LT
823{
824 struct cifsInodeInfo *cifsi = inode;
825
a35afb83
CL
826 inode_init_once(&cifsi->vfs_inode);
827 INIT_LIST_HEAD(&cifsi->lockList);
1da177e4
LT
828}
829
830static int
831cifs_init_inodecache(void)
832{
833 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
26f57364 834 sizeof(struct cifsInodeInfo),
fffb60f9
PJ
835 0, (SLAB_RECLAIM_ACCOUNT|
836 SLAB_MEM_SPREAD),
20c2df83 837 cifs_init_once);
1da177e4
LT
838 if (cifs_inode_cachep == NULL)
839 return -ENOMEM;
840
841 return 0;
842}
843
844static void
845cifs_destroy_inodecache(void)
846{
1a1d92c1 847 kmem_cache_destroy(cifs_inode_cachep);
1da177e4
LT
848}
849
850static int
851cifs_init_request_bufs(void)
852{
4523cc30 853 if (CIFSMaxBufSize < 8192) {
1da177e4
LT
854 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
855 Unicode path name has to fit in any SMB/CIFS path based frames */
856 CIFSMaxBufSize = 8192;
857 } else if (CIFSMaxBufSize > 1024*127) {
858 CIFSMaxBufSize = 1024 * 127;
859 } else {
860 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
861 }
862/* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
863 cifs_req_cachep = kmem_cache_create("cifs_request",
864 CIFSMaxBufSize +
865 MAX_CIFS_HDR_SIZE, 0,
20c2df83 866 SLAB_HWCACHE_ALIGN, NULL);
1da177e4
LT
867 if (cifs_req_cachep == NULL)
868 return -ENOMEM;
869
4523cc30 870 if (cifs_min_rcv < 1)
1da177e4
LT
871 cifs_min_rcv = 1;
872 else if (cifs_min_rcv > 64) {
873 cifs_min_rcv = 64;
50c2f753 874 cERROR(1, ("cifs_min_rcv set to maximum (64)"));
1da177e4
LT
875 }
876
93d2341c
MD
877 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
878 cifs_req_cachep);
1da177e4 879
4523cc30 880 if (cifs_req_poolp == NULL) {
1da177e4
LT
881 kmem_cache_destroy(cifs_req_cachep);
882 return -ENOMEM;
883 }
ec637e3f 884 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1da177e4
LT
885 almost all handle based requests (but not write response, nor is it
886 sufficient for path based requests). A smaller size would have
50c2f753 887 been more efficient (compacting multiple slab items on one 4k page)
1da177e4
LT
888 for the case in which debug was on, but this larger size allows
889 more SMBs to use small buffer alloc and is still much more
6dc0f87e 890 efficient to alloc 1 per page off the slab compared to 17K (5page)
1da177e4
LT
891 alloc of large cifs buffers even when page debugging is on */
892 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
6dc0f87e 893 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
20c2df83 894 NULL);
1da177e4
LT
895 if (cifs_sm_req_cachep == NULL) {
896 mempool_destroy(cifs_req_poolp);
897 kmem_cache_destroy(cifs_req_cachep);
6dc0f87e 898 return -ENOMEM;
1da177e4
LT
899 }
900
4523cc30 901 if (cifs_min_small < 2)
1da177e4
LT
902 cifs_min_small = 2;
903 else if (cifs_min_small > 256) {
904 cifs_min_small = 256;
6dc0f87e 905 cFYI(1, ("cifs_min_small set to maximum (256)"));
1da177e4
LT
906 }
907
93d2341c
MD
908 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
909 cifs_sm_req_cachep);
1da177e4 910
4523cc30 911 if (cifs_sm_req_poolp == NULL) {
1da177e4
LT
912 mempool_destroy(cifs_req_poolp);
913 kmem_cache_destroy(cifs_req_cachep);
914 kmem_cache_destroy(cifs_sm_req_cachep);
915 return -ENOMEM;
916 }
917
918 return 0;
919}
920
921static void
922cifs_destroy_request_bufs(void)
923{
924 mempool_destroy(cifs_req_poolp);
1a1d92c1 925 kmem_cache_destroy(cifs_req_cachep);
1da177e4 926 mempool_destroy(cifs_sm_req_poolp);
1a1d92c1 927 kmem_cache_destroy(cifs_sm_req_cachep);
1da177e4
LT
928}
929
930static int
931cifs_init_mids(void)
932{
933 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
26f57364
SF
934 sizeof(struct mid_q_entry), 0,
935 SLAB_HWCACHE_ALIGN, NULL);
1da177e4
LT
936 if (cifs_mid_cachep == NULL)
937 return -ENOMEM;
938
93d2341c
MD
939 /* 3 is a reasonable minimum number of simultaneous operations */
940 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
4523cc30 941 if (cifs_mid_poolp == NULL) {
1da177e4
LT
942 kmem_cache_destroy(cifs_mid_cachep);
943 return -ENOMEM;
944 }
945
946 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
26f57364
SF
947 sizeof(struct oplock_q_entry), 0,
948 SLAB_HWCACHE_ALIGN, NULL);
1da177e4 949 if (cifs_oplock_cachep == NULL) {
1da177e4 950 mempool_destroy(cifs_mid_poolp);
e6985c7f 951 kmem_cache_destroy(cifs_mid_cachep);
1da177e4
LT
952 return -ENOMEM;
953 }
954
955 return 0;
956}
957
958static void
959cifs_destroy_mids(void)
960{
961 mempool_destroy(cifs_mid_poolp);
1a1d92c1
AD
962 kmem_cache_destroy(cifs_mid_cachep);
963 kmem_cache_destroy(cifs_oplock_cachep);
1da177e4
LT
964}
965
50c2f753 966static int cifs_oplock_thread(void *dummyarg)
1da177e4 967{
6dc0f87e 968 struct oplock_q_entry *oplock_item;
1da177e4 969 struct cifsTconInfo *pTcon;
6dc0f87e 970 struct inode *inode;
1da177e4 971 __u16 netfid;
cea21805 972 int rc, waitrc = 0;
1da177e4 973
83144186 974 set_freezable();
1da177e4 975 do {
6dc0f87e 976 if (try_to_freeze())
ede1327e 977 continue;
50c2f753 978
1da177e4 979 spin_lock(&GlobalMid_Lock);
4523cc30 980 if (list_empty(&GlobalOplock_Q)) {
1da177e4
LT
981 spin_unlock(&GlobalMid_Lock);
982 set_current_state(TASK_INTERRUPTIBLE);
983 schedule_timeout(39*HZ);
984 } else {
6dc0f87e 985 oplock_item = list_entry(GlobalOplock_Q.next,
ad8b15f0
SF
986 struct oplock_q_entry, qhead);
987 cFYI(1, ("found oplock item to write out"));
988 pTcon = oplock_item->tcon;
989 inode = oplock_item->pinode;
990 netfid = oplock_item->netfid;
991 spin_unlock(&GlobalMid_Lock);
992 DeleteOplockQEntry(oplock_item);
993 /* can not grab inode sem here since it would
6dc0f87e 994 deadlock when oplock received on delete
1b1dcc1b 995 since vfs_unlink holds the i_mutex across
1da177e4 996 the call */
ad8b15f0
SF
997 /* mutex_lock(&inode->i_mutex);*/
998 if (S_ISREG(inode->i_mode)) {
84210e91
SF
999#ifdef CONFIG_CIFS_EXPERIMENTAL
1000 if (CIFS_I(inode)->clientCanCacheAll == 0)
1001 break_lease(inode, FMODE_READ);
1002 else if (CIFS_I(inode)->clientCanCacheRead == 0)
1003 break_lease(inode, FMODE_WRITE);
1004#endif
ad8b15f0
SF
1005 rc = filemap_fdatawrite(inode->i_mapping);
1006 if (CIFS_I(inode)->clientCanCacheRead == 0) {
1007 waitrc = filemap_fdatawait(
1008 inode->i_mapping);
1009 invalidate_remote_inode(inode);
1010 }
1011 if (rc == 0)
1012 rc = waitrc;
1013 } else
1014 rc = 0;
1015 /* mutex_unlock(&inode->i_mutex);*/
1016 if (rc)
1017 CIFS_I(inode)->write_behind_rc = rc;
1018 cFYI(1, ("Oplock flush inode %p rc %d",
1019 inode, rc));
6dc0f87e
SF
1020
1021 /* releasing stale oplock after recent reconnect
1022 of smb session using a now incorrect file
1023 handle is not a data integrity issue but do
1024 not bother sending an oplock release if session
1025 to server still is disconnected since oplock
1da177e4 1026 already released by the server in that case */
3b795210 1027 if (!pTcon->need_reconnect) {
ad8b15f0
SF
1028 rc = CIFSSMBLock(0, pTcon, netfid,
1029 0 /* len */ , 0 /* offset */, 0,
1030 0, LOCKING_ANDX_OPLOCK_RELEASE,
1031 false /* wait flag */);
1032 cFYI(1, ("Oplock release rc = %d", rc));
1033 }
68058e75
SF
1034 set_current_state(TASK_INTERRUPTIBLE);
1035 schedule_timeout(1); /* yield in case q were corrupt */
1da177e4 1036 }
45af7a0f
SF
1037 } while (!kthread_should_stop());
1038
1039 return 0;
1da177e4
LT
1040}
1041
954d7a1c 1042#ifdef CONFIG_CIFS_EXPERIMENTAL
50c2f753 1043static int cifs_dnotify_thread(void *dummyarg)
8d0d5094 1044{
6ab16d24 1045 struct list_head *tmp;
14fbf50d 1046 struct TCP_Server_Info *server;
6ab16d24 1047
8d0d5094 1048 do {
0fd1ffe0 1049 if (try_to_freeze())
16abbecd 1050 continue;
8d0d5094 1051 set_current_state(TASK_INTERRUPTIBLE);
6ab16d24 1052 schedule_timeout(15*HZ);
6ab16d24
SF
1053 /* check if any stuck requests that need
1054 to be woken up and wakeq so the
1055 thread can wake up and error out */
14fbf50d
JL
1056 read_lock(&cifs_tcp_ses_lock);
1057 list_for_each(tmp, &cifs_tcp_ses_list) {
1058 server = list_entry(tmp, struct TCP_Server_Info,
1059 tcp_ses_list);
1060 if (atomic_read(&server->inFlight))
1061 wake_up_all(&server->response_q);
6ab16d24 1062 }
14fbf50d 1063 read_unlock(&cifs_tcp_ses_lock);
45af7a0f
SF
1064 } while (!kthread_should_stop());
1065
1066 return 0;
1da177e4 1067}
954d7a1c 1068#endif
1da177e4
LT
1069
1070static int __init
1071init_cifs(void)
1072{
1073 int rc = 0;
1da177e4 1074 cifs_proc_init();
e7ddee90 1075 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1da177e4 1076 INIT_LIST_HEAD(&GlobalOplock_Q);
4ca9c190
SF
1077#ifdef CONFIG_CIFS_EXPERIMENTAL
1078 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1079 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
6dc0f87e 1080#endif
1da177e4
LT
1081/*
1082 * Initialize Global counters
1083 */
1084 atomic_set(&sesInfoAllocCount, 0);
1085 atomic_set(&tconInfoAllocCount, 0);
6dc0f87e 1086 atomic_set(&tcpSesAllocCount, 0);
1da177e4
LT
1087 atomic_set(&tcpSesReconnectCount, 0);
1088 atomic_set(&tconInfoReconnectCount, 0);
1089
1090 atomic_set(&bufAllocCount, 0);
4498eed5
SF
1091 atomic_set(&smBufAllocCount, 0);
1092#ifdef CONFIG_CIFS_STATS2
1093 atomic_set(&totBufAllocCount, 0);
1094 atomic_set(&totSmBufAllocCount, 0);
1095#endif /* CONFIG_CIFS_STATS2 */
1096
1da177e4
LT
1097 atomic_set(&midCount, 0);
1098 GlobalCurrentXid = 0;
1099 GlobalTotalActiveXid = 0;
1100 GlobalMaxActiveXid = 0;
2cd646a2 1101 memset(Local_System_Name, 0, 15);
1da177e4 1102 rwlock_init(&GlobalSMBSeslock);
e7ddee90 1103 rwlock_init(&cifs_tcp_ses_lock);
1da177e4
LT
1104 spin_lock_init(&GlobalMid_Lock);
1105
4523cc30 1106 if (cifs_max_pending < 2) {
1da177e4 1107 cifs_max_pending = 2;
6dc0f87e 1108 cFYI(1, ("cifs_max_pending set to min of 2"));
4523cc30 1109 } else if (cifs_max_pending > 256) {
1da177e4 1110 cifs_max_pending = 256;
6dc0f87e 1111 cFYI(1, ("cifs_max_pending set to max of 256"));
1da177e4
LT
1112 }
1113
1114 rc = cifs_init_inodecache();
45af7a0f
SF
1115 if (rc)
1116 goto out_clean_proc;
1117
1118 rc = cifs_init_mids();
1119 if (rc)
1120 goto out_destroy_inodecache;
1121
1122 rc = cifs_init_request_bufs();
1123 if (rc)
1124 goto out_destroy_mids;
1125
1126 rc = register_filesystem(&cifs_fs_type);
1127 if (rc)
1128 goto out_destroy_request_bufs;
84a15b93
JL
1129#ifdef CONFIG_CIFS_UPCALL
1130 rc = register_key_type(&cifs_spnego_key_type);
1131 if (rc)
1132 goto out_unregister_filesystem;
6103335d
SF
1133#endif
1134#ifdef CONFIG_CIFS_DFS_UPCALL
1135 rc = register_key_type(&key_type_dns_resolver);
1136 if (rc)
1137 goto out_unregister_key_type;
84a15b93 1138#endif
45af7a0f
SF
1139 oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
1140 if (IS_ERR(oplockThread)) {
1141 rc = PTR_ERR(oplockThread);
6dc0f87e 1142 cERROR(1, ("error %d create oplock thread", rc));
6103335d 1143 goto out_unregister_dfs_key_type;
1da177e4 1144 }
45af7a0f 1145
954d7a1c 1146#ifdef CONFIG_CIFS_EXPERIMENTAL
45af7a0f
SF
1147 dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
1148 if (IS_ERR(dnotifyThread)) {
1149 rc = PTR_ERR(dnotifyThread);
6dc0f87e 1150 cERROR(1, ("error %d create dnotify thread", rc));
45af7a0f
SF
1151 goto out_stop_oplock_thread;
1152 }
954d7a1c 1153#endif
45af7a0f
SF
1154
1155 return 0;
1156
954d7a1c 1157#ifdef CONFIG_CIFS_EXPERIMENTAL
45af7a0f 1158 out_stop_oplock_thread:
954d7a1c 1159#endif
45af7a0f 1160 kthread_stop(oplockThread);
6103335d
SF
1161 out_unregister_dfs_key_type:
1162#ifdef CONFIG_CIFS_DFS_UPCALL
1163 unregister_key_type(&key_type_dns_resolver);
84a15b93 1164 out_unregister_key_type:
6103335d 1165#endif
84a15b93
JL
1166#ifdef CONFIG_CIFS_UPCALL
1167 unregister_key_type(&cifs_spnego_key_type);
45af7a0f 1168 out_unregister_filesystem:
84a15b93 1169#endif
45af7a0f
SF
1170 unregister_filesystem(&cifs_fs_type);
1171 out_destroy_request_bufs:
1172 cifs_destroy_request_bufs();
1173 out_destroy_mids:
1174 cifs_destroy_mids();
1175 out_destroy_inodecache:
1176 cifs_destroy_inodecache();
1177 out_clean_proc:
1da177e4 1178 cifs_proc_clean();
1da177e4
LT
1179 return rc;
1180}
1181
1182static void __exit
1183exit_cifs(void)
1184{
90c81e0b 1185 cFYI(DBG2, ("exit_cifs"));
1da177e4 1186 cifs_proc_clean();
6103335d 1187#ifdef CONFIG_CIFS_DFS_UPCALL
78d31a3a 1188 cifs_dfs_release_automount_timer();
6103335d
SF
1189 unregister_key_type(&key_type_dns_resolver);
1190#endif
84a15b93
JL
1191#ifdef CONFIG_CIFS_UPCALL
1192 unregister_key_type(&cifs_spnego_key_type);
1da177e4
LT
1193#endif
1194 unregister_filesystem(&cifs_fs_type);
1195 cifs_destroy_inodecache();
1196 cifs_destroy_mids();
1197 cifs_destroy_request_bufs();
954d7a1c 1198#ifdef CONFIG_CIFS_EXPERIMENTAL
45af7a0f 1199 kthread_stop(dnotifyThread);
954d7a1c
JL
1200#endif
1201 kthread_stop(oplockThread);
1da177e4
LT
1202}
1203
1204MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
6dc0f87e 1205MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1da177e4 1206MODULE_DESCRIPTION
63135e08
SF
1207 ("VFS to access servers complying with the SNIA CIFS Specification "
1208 "e.g. Samba and Windows");
1da177e4
LT
1209MODULE_VERSION(CIFS_VERSION);
1210module_init(init_cifs)
1211module_exit(exit_cifs)