blob: faba4d69fe91fbcd12279c3683d88a03d479830a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/cifsfs.c
3 *
Steve French35c11fd2007-02-27 05:09:35 +00004 * Copyright (C) International Business Machines Corp., 2002,2007
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * 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>
Steve French6ab16d22005-11-29 20:55:11 -080035#include <linux/delay.h>
Steve French45af7a02006-04-21 22:52:25 +000036#include <linux/kthread.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080037#include <linux/freezer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#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>
46#define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
47
48#ifdef CONFIG_CIFS_QUOTA
49static struct quotactl_ops cifs_quotactl_ops;
Steve French35c11fd2007-02-27 05:09:35 +000050#endif /* QUOTA */
51
52#ifdef CONFIG_CIFS_EXPERIMENTAL
53extern struct export_operations cifs_export_ops;
54#endif /* EXPERIMENTAL */
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
56int cifsFYI = 0;
57int cifsERROR = 1;
58int traceSMB = 0;
59unsigned int oplockEnabled = 1;
60unsigned int experimEnabled = 0;
61unsigned int linuxExtEnabled = 1;
62unsigned int lookupCacheEnabled = 1;
63unsigned int multiuser_mount = 0;
Steve French39798772006-05-31 22:40:51 +000064unsigned int extended_security = CIFSSEC_DEF;
65/* unsigned int ntlmv2_support = 0; */
Linus Torvalds1da177e2005-04-16 15:20:36 -070066unsigned int sign_CIFS_PDUs = 1;
67extern struct task_struct * oplockThread; /* remove sparse warning */
68struct task_struct * oplockThread = NULL;
Steve French99ee4db2007-02-27 05:35:17 +000069/* extern struct task_struct * dnotifyThread; remove sparse warning */
70static struct task_struct * dnotifyThread = NULL;
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -080071static const struct super_operations cifs_super_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070072unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
73module_param(CIFSMaxBufSize, int, 0);
74MODULE_PARM_DESC(CIFSMaxBufSize,"Network buffer size (not including header). Default: 16384 Range: 8192 to 130048");
75unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
76module_param(cifs_min_rcv, int, 0);
77MODULE_PARM_DESC(cifs_min_rcv,"Network buffers in pool. Default: 4 Range: 1 to 64");
78unsigned int cifs_min_small = 30;
79module_param(cifs_min_small, int, 0);
80MODULE_PARM_DESC(cifs_min_small,"Small network buffers in pool. Default: 30 Range: 2 to 256");
81unsigned int cifs_max_pending = CIFS_MAX_REQ;
82module_param(cifs_max_pending, int, 0);
83MODULE_PARM_DESC(cifs_max_pending,"Simultaneous requests to server. Default: 50 Range: 2 to 256");
84
Linus Torvalds1da177e2005-04-16 15:20:36 -070085extern mempool_t *cifs_sm_req_poolp;
86extern mempool_t *cifs_req_poolp;
87extern mempool_t *cifs_mid_poolp;
88
Christoph Lametere18b8902006-12-06 20:33:20 -080089extern struct kmem_cache *cifs_oplock_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
91static int
92cifs_read_super(struct super_block *sb, void *data,
93 const char *devname, int silent)
94{
95 struct inode *inode;
96 struct cifs_sb_info *cifs_sb;
97 int rc = 0;
Steve French1b2b2122007-02-17 04:30:54 +000098
99 /* BB should we make this contingent on mount parm? */
100 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
Eric Sesterhenna048d7a2006-02-21 22:33:09 +0000101 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info),GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 cifs_sb = CIFS_SB(sb);
103 if(cifs_sb == NULL)
104 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
106 rc = cifs_mount(sb, cifs_sb, data, devname);
107
108 if (rc) {
109 if (!silent)
110 cERROR(1,
111 ("cifs_mount failed w/return code = %d", rc));
112 goto out_mount_failed;
113 }
114
115 sb->s_magic = CIFS_MAGIC_NUMBER;
116 sb->s_op = &cifs_super_ops;
Steve French35c11fd2007-02-27 05:09:35 +0000117#ifdef CONFIG_CIFS_EXPERIMENTAL
118 if(experimEnabled != 0)
119 sb->s_export_op = &cifs_export_ops;
120#endif /* EXPERIMENTAL */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121/* if(cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
122 sb->s_blocksize = cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
123#ifdef CONFIG_CIFS_QUOTA
124 sb->s_qcop = &cifs_quotactl_ops;
125#endif
126 sb->s_blocksize = CIFS_MAX_MSGSIZE;
127 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
128 inode = iget(sb, ROOT_I);
129
130 if (!inode) {
131 rc = -ENOMEM;
132 goto out_no_root;
133 }
134
135 sb->s_root = d_alloc_root(inode);
136
137 if (!sb->s_root) {
138 rc = -ENOMEM;
139 goto out_no_root;
140 }
141
142 return 0;
143
144out_no_root:
145 cERROR(1, ("cifs_read_super: get root inode failed"));
146 if (inode)
147 iput(inode);
148
149out_mount_failed:
150 if(cifs_sb) {
151 if(cifs_sb->local_nls)
152 unload_nls(cifs_sb->local_nls);
153 kfree(cifs_sb);
154 }
155 return rc;
156}
157
158static void
159cifs_put_super(struct super_block *sb)
160{
161 int rc = 0;
162 struct cifs_sb_info *cifs_sb;
163
164 cFYI(1, ("In cifs_put_super"));
165 cifs_sb = CIFS_SB(sb);
166 if(cifs_sb == NULL) {
167 cFYI(1,("Empty cifs superblock info passed to unmount"));
168 return;
169 }
170 rc = cifs_umount(sb, cifs_sb);
171 if (rc) {
172 cERROR(1, ("cifs_umount failed with return code %d", rc));
173 }
174 unload_nls(cifs_sb->local_nls);
175 kfree(cifs_sb);
176 return;
177}
178
179static int
David Howells726c3342006-06-23 02:02:58 -0700180cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181{
David Howells726c3342006-06-23 02:02:58 -0700182 struct super_block *sb = dentry->d_sb;
Steve Frenchc81156d2005-04-28 22:41:07 -0700183 int xid;
184 int rc = -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 struct cifs_sb_info *cifs_sb;
186 struct cifsTconInfo *pTcon;
187
188 xid = GetXid();
189
190 cifs_sb = CIFS_SB(sb);
191 pTcon = cifs_sb->tcon;
192
193 buf->f_type = CIFS_MAGIC_NUMBER;
194
195 /* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */
Steve Frenchc81156d2005-04-28 22:41:07 -0700196 buf->f_namelen = PATH_MAX; /* PATH_MAX may be too long - it would
197 presumably be total path, but note
198 that some servers (includinng Samba 3)
199 have a shorter maximum path */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 buf->f_files = 0; /* undefined */
201 buf->f_ffree = 0; /* unlimited */
202
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203/* BB we could add a second check for a QFS Unix capability bit */
Steve Frenchf28ac912005-04-28 22:41:07 -0700204/* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */
Steve Frenchc81156d2005-04-28 22:41:07 -0700205 if ((pTcon->ses->capabilities & CAP_UNIX) && (CIFS_POSIX_EXTENSIONS &
206 le64_to_cpu(pTcon->fsUnixInfo.Capability)))
Steve French737b7582005-04-28 22:41:06 -0700207 rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208
209 /* Only need to call the old QFSInfo if failed
210 on newer one */
211 if(rc)
Steve Frenchde7ed552006-09-30 13:25:52 +0000212 if(pTcon->ses->capabilities & CAP_NT_SMBS)
Steve French9ac00b72006-09-30 04:13:17 +0000213 rc = CIFSSMBQFSInfo(xid, pTcon, buf); /* not supported by OS2 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
Steve French9ac00b72006-09-30 04:13:17 +0000215 /* Some old Windows servers also do not support level 103, retry with
216 older level one if old server failed the previous call or we
217 bypassed it because we detected that this was an older LANMAN sess */
Steve French20962432005-09-21 22:05:57 -0700218 if(rc)
219 rc = SMBOldQFSInfo(xid, pTcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 /*
221 int f_type;
222 __fsid_t f_fsid;
223 int f_namelen; */
Steve Frenchc81156d2005-04-28 22:41:07 -0700224 /* BB get from info in tcon struct at mount time call to QFSAttrInfo */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 FreeXid(xid);
Steve Frenchc81156d2005-04-28 22:41:07 -0700226 return 0; /* always return success? what if volume is no
227 longer available? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228}
229
230static int cifs_permission(struct inode * inode, int mask, struct nameidata *nd)
231{
232 struct cifs_sb_info *cifs_sb;
233
234 cifs_sb = CIFS_SB(inode->i_sb);
235
236 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
237 return 0;
238 } else /* file mode might have been restricted at mount time
239 on the client (above and beyond ACL on servers) for
240 servers which do not support setting and viewing mode bits,
241 so allowing client to check permissions is useful */
242 return generic_permission(inode, mask, NULL);
243}
244
Christoph Lametere18b8902006-12-06 20:33:20 -0800245static struct kmem_cache *cifs_inode_cachep;
246static struct kmem_cache *cifs_req_cachep;
247static struct kmem_cache *cifs_mid_cachep;
248struct kmem_cache *cifs_oplock_cachep;
249static struct kmem_cache *cifs_sm_req_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250mempool_t *cifs_sm_req_poolp;
251mempool_t *cifs_req_poolp;
252mempool_t *cifs_mid_poolp;
253
254static struct inode *
255cifs_alloc_inode(struct super_block *sb)
256{
257 struct cifsInodeInfo *cifs_inode;
Christoph Lametere94b1762006-12-06 20:33:17 -0800258 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 if (!cifs_inode)
260 return NULL;
261 cifs_inode->cifsAttrs = 0x20; /* default */
262 atomic_set(&cifs_inode->inUse, 0);
263 cifs_inode->time = 0;
264 /* Until the file is open and we have gotten oplock
265 info back from the server, can not assume caching of
266 file data or metadata */
267 cifs_inode->clientCanCacheRead = FALSE;
268 cifs_inode->clientCanCacheAll = FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
Steve French1b2b2122007-02-17 04:30:54 +0000270
271 /* Can not set i_flags here - they get immediately overwritten
272 to zero by the VFS */
273/* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 INIT_LIST_HEAD(&cifs_inode->openFileList);
275 return &cifs_inode->vfs_inode;
276}
277
278static void
279cifs_destroy_inode(struct inode *inode)
280{
281 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
282}
283
284/*
285 * cifs_show_options() is for displaying mount options in /proc/mounts.
286 * Not all settable options are displayed but most of the important
287 * ones are.
288 */
289static int
290cifs_show_options(struct seq_file *s, struct vfsmount *m)
291{
292 struct cifs_sb_info *cifs_sb;
293
294 cifs_sb = CIFS_SB(m->mnt_sb);
295
296 if (cifs_sb) {
297 if (cifs_sb->tcon) {
Steve French004c46b2007-02-17 04:34:13 +0000298/* BB add prepath to mount options displayed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
300 if (cifs_sb->tcon->ses) {
301 if (cifs_sb->tcon->ses->userName)
302 seq_printf(s, ",username=%s",
303 cifs_sb->tcon->ses->userName);
304 if(cifs_sb->tcon->ses->domainName)
305 seq_printf(s, ",domain=%s",
306 cifs_sb->tcon->ses->domainName);
307 }
308 }
309 seq_printf(s, ",rsize=%d",cifs_sb->rsize);
310 seq_printf(s, ",wsize=%d",cifs_sb->wsize);
311 }
312 return 0;
313}
314
315#ifdef CONFIG_CIFS_QUOTA
316int cifs_xquota_set(struct super_block * sb, int quota_type, qid_t qid,
317 struct fs_disk_quota * pdquota)
318{
319 int xid;
320 int rc = 0;
321 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
322 struct cifsTconInfo *pTcon;
323
324 if(cifs_sb)
325 pTcon = cifs_sb->tcon;
326 else
327 return -EIO;
328
329
330 xid = GetXid();
331 if(pTcon) {
332 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
333 } else {
334 return -EIO;
335 }
336
337 FreeXid(xid);
338 return rc;
339}
340
341int cifs_xquota_get(struct super_block * sb, int quota_type, qid_t qid,
342 struct fs_disk_quota * pdquota)
343{
344 int xid;
345 int rc = 0;
346 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
347 struct cifsTconInfo *pTcon;
348
349 if(cifs_sb)
350 pTcon = cifs_sb->tcon;
351 else
352 return -EIO;
353
354 xid = GetXid();
355 if(pTcon) {
356 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
357 } else {
358 rc = -EIO;
359 }
360
361 FreeXid(xid);
362 return rc;
363}
364
365int cifs_xstate_set(struct super_block * sb, unsigned int flags, int operation)
366{
367 int xid;
368 int rc = 0;
369 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
370 struct cifsTconInfo *pTcon;
371
372 if(cifs_sb)
373 pTcon = cifs_sb->tcon;
374 else
375 return -EIO;
376
377 xid = GetXid();
378 if(pTcon) {
379 cFYI(1,("flags: 0x%x operation: 0x%x",flags,operation));
380 } else {
381 rc = -EIO;
382 }
383
384 FreeXid(xid);
385 return rc;
386}
387
388int cifs_xstate_get(struct super_block * sb, struct fs_quota_stat *qstats)
389{
390 int xid;
391 int rc = 0;
392 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
393 struct cifsTconInfo *pTcon;
394
395 if(cifs_sb) {
396 pTcon = cifs_sb->tcon;
397 } else {
398 return -EIO;
399 }
400 xid = GetXid();
401 if(pTcon) {
402 cFYI(1,("pqstats %p",qstats));
403 } else {
404 rc = -EIO;
405 }
406
407 FreeXid(xid);
408 return rc;
409}
410
411static struct quotactl_ops cifs_quotactl_ops = {
412 .set_xquota = cifs_xquota_set,
413 .get_xquota = cifs_xquota_set,
414 .set_xstate = cifs_xstate_set,
415 .get_xstate = cifs_xstate_get,
416};
417#endif
418
Trond Myklebust8b512d92006-06-09 09:34:18 -0400419static void cifs_umount_begin(struct vfsmount * vfsmnt, int flags)
Steve French68058e72005-10-10 10:34:22 -0700420{
Steve French5e1253b2005-10-10 14:06:37 -0700421 struct cifs_sb_info *cifs_sb;
Steve French9e2e85f2005-10-10 14:28:38 -0700422 struct cifsTconInfo * tcon;
Steve French68058e72005-10-10 10:34:22 -0700423
Trond Myklebust8b512d92006-06-09 09:34:18 -0400424 if (!(flags & MNT_FORCE))
425 return;
426 cifs_sb = CIFS_SB(vfsmnt->mnt_sb);
Steve French5e1253b2005-10-10 14:06:37 -0700427 if(cifs_sb == NULL)
Steve French9e2e85f2005-10-10 14:28:38 -0700428 return;
429
430 tcon = cifs_sb->tcon;
431 if(tcon == NULL)
432 return;
Steve French5e1253b2005-10-10 14:06:37 -0700433 down(&tcon->tconSem);
434 if (atomic_read(&tcon->useCount) == 1)
435 tcon->tidStatus = CifsExiting;
436 up(&tcon->tconSem);
437
Steve French3a5ff612006-07-14 22:37:11 +0000438 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
Steve French7b7abfe2005-11-09 15:21:09 -0800439 /* cancel_notify_requests(tcon); */
Steve French9e2e85f2005-10-10 14:28:38 -0700440 if(tcon->ses && tcon->ses->server)
Steve French5e1253b2005-10-10 14:06:37 -0700441 {
Steve French7b7abfe2005-11-09 15:21:09 -0800442 cFYI(1,("wake up tasks now - umount begin not complete"));
Steve French9e2e85f2005-10-10 14:28:38 -0700443 wake_up_all(&tcon->ses->server->request_q);
Steve French6ab16d22005-11-29 20:55:11 -0800444 wake_up_all(&tcon->ses->server->response_q);
445 msleep(1); /* yield */
446 /* we have to kick the requests once more */
447 wake_up_all(&tcon->ses->server->response_q);
448 msleep(1);
Steve French5e1253b2005-10-10 14:06:37 -0700449 }
450/* BB FIXME - finish add checks for tidStatus BB */
Steve French68058e72005-10-10 10:34:22 -0700451
452 return;
453}
Steve French68058e72005-10-10 10:34:22 -0700454
Steve Frenchbf97d282006-09-28 21:34:06 +0000455#ifdef CONFIG_CIFS_STATS2
456static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
457{
458 /* BB FIXME */
459 return 0;
460}
461#endif
462
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463static int cifs_remount(struct super_block *sb, int *flags, char *data)
464{
465 *flags |= MS_NODIRATIME;
466 return 0;
467}
468
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800469static const struct super_operations cifs_super_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 .read_inode = cifs_read_inode,
471 .put_super = cifs_put_super,
472 .statfs = cifs_statfs,
473 .alloc_inode = cifs_alloc_inode,
474 .destroy_inode = cifs_destroy_inode,
475/* .drop_inode = generic_delete_inode,
476 .delete_inode = cifs_delete_inode, *//* Do not need the above two functions
477 unless later we add lazy close of inodes or unless the kernel forgets to call
478 us with the same number of releases (closes) as opens */
479 .show_options = cifs_show_options,
Steve French7b7abfe2005-11-09 15:21:09 -0800480 .umount_begin = cifs_umount_begin,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 .remount_fs = cifs_remount,
Steve Frenchbf97d282006-09-28 21:34:06 +0000482#ifdef CONFIG_CIFS_STATS2
Steve Frenchf46d3e12006-09-30 01:08:55 +0000483 .show_stats = cifs_show_stats,
Steve Frenchbf97d282006-09-28 21:34:06 +0000484#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485};
486
David Howells454e2392006-06-23 02:02:57 -0700487static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488cifs_get_sb(struct file_system_type *fs_type,
David Howells454e2392006-06-23 02:02:57 -0700489 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490{
491 int rc;
492 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
493
494 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
495
496 if (IS_ERR(sb))
David Howells454e2392006-06-23 02:02:57 -0700497 return PTR_ERR(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
499 sb->s_flags = flags;
500
Theodore Ts'o9b04c992006-03-24 03:15:10 -0800501 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 if (rc) {
503 up_write(&sb->s_umount);
504 deactivate_super(sb);
David Howells454e2392006-06-23 02:02:57 -0700505 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 }
507 sb->s_flags |= MS_ACTIVE;
David Howells454e2392006-06-23 02:02:57 -0700508 return simple_set_mnt(mnt, sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509}
510
Badari Pulavarty027445c2006-09-30 23:28:46 -0700511static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
512 unsigned long nr_segs, loff_t pos)
Steve French87c89dd2005-11-17 17:03:00 -0800513{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800514 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
Steve French87c89dd2005-11-17 17:03:00 -0800515 ssize_t written;
516
Badari Pulavarty027445c2006-09-30 23:28:46 -0700517 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
Steve French87c89dd2005-11-17 17:03:00 -0800518 if (!CIFS_I(inode)->clientCanCacheAll)
519 filemap_fdatawrite(inode->i_mapping);
520 return written;
521}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522
Steve Frenchc32a0b62006-01-12 14:41:28 -0800523static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
524{
525 /* origin == SEEK_END => we must revalidate the cached file length */
Steve French0889a942006-09-23 22:11:07 +0000526 if (origin == SEEK_END) {
Steve French030e9d82007-02-01 04:27:59 +0000527 int retval;
528
529 /* some applications poll for the file length in this strange
530 way so we must seek to end on non-oplocked files by
531 setting the revalidate time to zero */
532 if(file->f_path.dentry->d_inode)
533 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
534
535 retval = cifs_revalidate(file->f_path.dentry);
Steve Frenchc32a0b62006-01-12 14:41:28 -0800536 if (retval < 0)
537 return (loff_t)retval;
538 }
539 return remote_llseek(file, offset, origin);
540}
541
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542static struct file_system_type cifs_fs_type = {
543 .owner = THIS_MODULE,
544 .name = "cifs",
545 .get_sb = cifs_get_sb,
546 .kill_sb = kill_anon_super,
547 /* .fs_flags */
548};
Arjan van de Ven754661f2007-02-12 00:55:38 -0800549const struct inode_operations cifs_dir_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 .create = cifs_create,
551 .lookup = cifs_lookup,
552 .getattr = cifs_getattr,
553 .unlink = cifs_unlink,
554 .link = cifs_hardlink,
555 .mkdir = cifs_mkdir,
556 .rmdir = cifs_rmdir,
557 .rename = cifs_rename,
558 .permission = cifs_permission,
559/* revalidate:cifs_revalidate, */
560 .setattr = cifs_setattr,
561 .symlink = cifs_symlink,
562 .mknod = cifs_mknod,
563#ifdef CONFIG_CIFS_XATTR
564 .setxattr = cifs_setxattr,
565 .getxattr = cifs_getxattr,
566 .listxattr = cifs_listxattr,
567 .removexattr = cifs_removexattr,
568#endif
569};
570
Arjan van de Ven754661f2007-02-12 00:55:38 -0800571const struct inode_operations cifs_file_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572/* revalidate:cifs_revalidate, */
573 .setattr = cifs_setattr,
574 .getattr = cifs_getattr, /* do we need this anymore? */
575 .rename = cifs_rename,
576 .permission = cifs_permission,
577#ifdef CONFIG_CIFS_XATTR
578 .setxattr = cifs_setxattr,
579 .getxattr = cifs_getxattr,
580 .listxattr = cifs_listxattr,
581 .removexattr = cifs_removexattr,
582#endif
583};
584
Arjan van de Ven754661f2007-02-12 00:55:38 -0800585const struct inode_operations cifs_symlink_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 .readlink = generic_readlink,
587 .follow_link = cifs_follow_link,
588 .put_link = cifs_put_link,
589 .permission = cifs_permission,
590 /* BB add the following two eventually */
591 /* revalidate: cifs_revalidate,
592 setattr: cifs_notify_change, *//* BB do we need notify change */
593#ifdef CONFIG_CIFS_XATTR
594 .setxattr = cifs_setxattr,
595 .getxattr = cifs_getxattr,
596 .listxattr = cifs_listxattr,
597 .removexattr = cifs_removexattr,
598#endif
599};
600
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800601const struct file_operations cifs_file_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800602 .read = do_sync_read,
603 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800604 .aio_read = generic_file_aio_read,
605 .aio_write = cifs_file_aio_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 .open = cifs_open,
607 .release = cifs_close,
608 .lock = cifs_lock,
609 .fsync = cifs_fsync,
610 .flush = cifs_flush,
611 .mmap = cifs_file_mmap,
612 .sendfile = generic_file_sendfile,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800613 .llseek = cifs_llseek,
Steve Frenchc67593a2005-04-28 22:41:04 -0700614#ifdef CONFIG_CIFS_POSIX
615 .ioctl = cifs_ioctl,
616#endif /* CONFIG_CIFS_POSIX */
617
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618#ifdef CONFIG_CIFS_EXPERIMENTAL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 .dir_notify = cifs_dir_notify,
620#endif /* CONFIG_CIFS_EXPERIMENTAL */
621};
622
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800623const struct file_operations cifs_file_direct_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 /* no mmap, no aio, no readv -
625 BB reevaluate whether they can be done with directio, no cache */
626 .read = cifs_user_read,
627 .write = cifs_user_write,
628 .open = cifs_open,
629 .release = cifs_close,
630 .lock = cifs_lock,
631 .fsync = cifs_fsync,
632 .flush = cifs_flush,
633 .sendfile = generic_file_sendfile, /* BB removeme BB */
Steve Frenchc67593a2005-04-28 22:41:04 -0700634#ifdef CONFIG_CIFS_POSIX
635 .ioctl = cifs_ioctl,
636#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800637 .llseek = cifs_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638#ifdef CONFIG_CIFS_EXPERIMENTAL
639 .dir_notify = cifs_dir_notify,
640#endif /* CONFIG_CIFS_EXPERIMENTAL */
641};
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800642const struct file_operations cifs_file_nobrl_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800643 .read = do_sync_read,
644 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800645 .aio_read = generic_file_aio_read,
646 .aio_write = cifs_file_aio_write,
647 .open = cifs_open,
648 .release = cifs_close,
649 .fsync = cifs_fsync,
650 .flush = cifs_flush,
651 .mmap = cifs_file_mmap,
652 .sendfile = generic_file_sendfile,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800653 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800654#ifdef CONFIG_CIFS_POSIX
Steve French87c89dd2005-11-17 17:03:00 -0800655 .ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800656#endif /* CONFIG_CIFS_POSIX */
657
658#ifdef CONFIG_CIFS_EXPERIMENTAL
Steve French87c89dd2005-11-17 17:03:00 -0800659 .dir_notify = cifs_dir_notify,
Steve French8b94bcb2005-11-11 11:41:00 -0800660#endif /* CONFIG_CIFS_EXPERIMENTAL */
661};
662
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800663const struct file_operations cifs_file_direct_nobrl_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800664 /* no mmap, no aio, no readv -
665 BB reevaluate whether they can be done with directio, no cache */
666 .read = cifs_user_read,
667 .write = cifs_user_write,
668 .open = cifs_open,
669 .release = cifs_close,
670 .fsync = cifs_fsync,
671 .flush = cifs_flush,
672 .sendfile = generic_file_sendfile, /* BB removeme BB */
Steve French8b94bcb2005-11-11 11:41:00 -0800673#ifdef CONFIG_CIFS_POSIX
Steve French87c89dd2005-11-17 17:03:00 -0800674 .ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800675#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800676 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800677#ifdef CONFIG_CIFS_EXPERIMENTAL
Steve French87c89dd2005-11-17 17:03:00 -0800678 .dir_notify = cifs_dir_notify,
Steve French8b94bcb2005-11-11 11:41:00 -0800679#endif /* CONFIG_CIFS_EXPERIMENTAL */
680};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800682const struct file_operations cifs_dir_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 .readdir = cifs_readdir,
684 .release = cifs_closedir,
685 .read = generic_read_dir,
686#ifdef CONFIG_CIFS_EXPERIMENTAL
687 .dir_notify = cifs_dir_notify,
688#endif /* CONFIG_CIFS_EXPERIMENTAL */
Steve Frenchf28ac912005-04-28 22:41:07 -0700689 .ioctl = cifs_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690};
691
692static void
Christoph Lametere18b8902006-12-06 20:33:20 -0800693cifs_init_once(void *inode, struct kmem_cache * cachep, unsigned long flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694{
695 struct cifsInodeInfo *cifsi = inode;
696
697 if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
698 SLAB_CTOR_CONSTRUCTOR) {
699 inode_init_once(&cifsi->vfs_inode);
700 INIT_LIST_HEAD(&cifsi->lockList);
701 }
702}
703
704static int
705cifs_init_inodecache(void)
706{
707 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
708 sizeof (struct cifsInodeInfo),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800709 0, (SLAB_RECLAIM_ACCOUNT|
710 SLAB_MEM_SPREAD),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 cifs_init_once, NULL);
712 if (cifs_inode_cachep == NULL)
713 return -ENOMEM;
714
715 return 0;
716}
717
718static void
719cifs_destroy_inodecache(void)
720{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700721 kmem_cache_destroy(cifs_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722}
723
724static int
725cifs_init_request_bufs(void)
726{
727 if(CIFSMaxBufSize < 8192) {
728 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
729 Unicode path name has to fit in any SMB/CIFS path based frames */
730 CIFSMaxBufSize = 8192;
731 } else if (CIFSMaxBufSize > 1024*127) {
732 CIFSMaxBufSize = 1024 * 127;
733 } else {
734 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
735 }
736/* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
737 cifs_req_cachep = kmem_cache_create("cifs_request",
738 CIFSMaxBufSize +
739 MAX_CIFS_HDR_SIZE, 0,
740 SLAB_HWCACHE_ALIGN, NULL, NULL);
741 if (cifs_req_cachep == NULL)
742 return -ENOMEM;
743
744 if(cifs_min_rcv < 1)
745 cifs_min_rcv = 1;
746 else if (cifs_min_rcv > 64) {
747 cifs_min_rcv = 64;
748 cERROR(1,("cifs_min_rcv set to maximum (64)"));
749 }
750
Matthew Dobson93d23412006-03-26 01:37:50 -0800751 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
752 cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753
754 if(cifs_req_poolp == NULL) {
755 kmem_cache_destroy(cifs_req_cachep);
756 return -ENOMEM;
757 }
Steve Frenchec637e32005-12-12 20:53:18 -0800758 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 almost all handle based requests (but not write response, nor is it
760 sufficient for path based requests). A smaller size would have
761 been more efficient (compacting multiple slab items on one 4k page)
762 for the case in which debug was on, but this larger size allows
763 more SMBs to use small buffer alloc and is still much more
764 efficient to alloc 1 per page off the slab compared to 17K (5page)
765 alloc of large cifs buffers even when page debugging is on */
766 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
Steve Frenchec637e32005-12-12 20:53:18 -0800767 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
768 NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 if (cifs_sm_req_cachep == NULL) {
770 mempool_destroy(cifs_req_poolp);
771 kmem_cache_destroy(cifs_req_cachep);
772 return -ENOMEM;
773 }
774
775 if(cifs_min_small < 2)
776 cifs_min_small = 2;
777 else if (cifs_min_small > 256) {
778 cifs_min_small = 256;
779 cFYI(1,("cifs_min_small set to maximum (256)"));
780 }
781
Matthew Dobson93d23412006-03-26 01:37:50 -0800782 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
783 cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
785 if(cifs_sm_req_poolp == NULL) {
786 mempool_destroy(cifs_req_poolp);
787 kmem_cache_destroy(cifs_req_cachep);
788 kmem_cache_destroy(cifs_sm_req_cachep);
789 return -ENOMEM;
790 }
791
792 return 0;
793}
794
795static void
796cifs_destroy_request_bufs(void)
797{
798 mempool_destroy(cifs_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700799 kmem_cache_destroy(cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 mempool_destroy(cifs_sm_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700801 kmem_cache_destroy(cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802}
803
804static int
805cifs_init_mids(void)
806{
807 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
808 sizeof (struct mid_q_entry), 0,
809 SLAB_HWCACHE_ALIGN, NULL, NULL);
810 if (cifs_mid_cachep == NULL)
811 return -ENOMEM;
812
Matthew Dobson93d23412006-03-26 01:37:50 -0800813 /* 3 is a reasonable minimum number of simultaneous operations */
814 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 if(cifs_mid_poolp == NULL) {
816 kmem_cache_destroy(cifs_mid_cachep);
817 return -ENOMEM;
818 }
819
820 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
821 sizeof (struct oplock_q_entry), 0,
822 SLAB_HWCACHE_ALIGN, NULL, NULL);
823 if (cifs_oplock_cachep == NULL) {
824 kmem_cache_destroy(cifs_mid_cachep);
825 mempool_destroy(cifs_mid_poolp);
826 return -ENOMEM;
827 }
828
829 return 0;
830}
831
832static void
833cifs_destroy_mids(void)
834{
835 mempool_destroy(cifs_mid_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700836 kmem_cache_destroy(cifs_mid_cachep);
837 kmem_cache_destroy(cifs_oplock_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838}
839
840static int cifs_oplock_thread(void * dummyarg)
841{
842 struct oplock_q_entry * oplock_item;
843 struct cifsTconInfo *pTcon;
844 struct inode * inode;
845 __u16 netfid;
846 int rc;
847
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 do {
Steve Frenchede13272005-08-30 20:10:14 -0700849 if (try_to_freeze())
850 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 spin_lock(&GlobalMid_Lock);
853 if(list_empty(&GlobalOplock_Q)) {
854 spin_unlock(&GlobalMid_Lock);
855 set_current_state(TASK_INTERRUPTIBLE);
856 schedule_timeout(39*HZ);
857 } else {
858 oplock_item = list_entry(GlobalOplock_Q.next,
859 struct oplock_q_entry, qhead);
860 if(oplock_item) {
861 cFYI(1,("found oplock item to write out"));
862 pTcon = oplock_item->tcon;
863 inode = oplock_item->pinode;
864 netfid = oplock_item->netfid;
865 spin_unlock(&GlobalMid_Lock);
866 DeleteOplockQEntry(oplock_item);
867 /* can not grab inode sem here since it would
868 deadlock when oplock received on delete
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800869 since vfs_unlink holds the i_mutex across
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 the call */
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800871 /* mutex_lock(&inode->i_mutex);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 if (S_ISREG(inode->i_mode)) {
873 rc = filemap_fdatawrite(inode->i_mapping);
874 if(CIFS_I(inode)->clientCanCacheRead == 0) {
875 filemap_fdatawait(inode->i_mapping);
876 invalidate_remote_inode(inode);
877 }
878 } else
879 rc = 0;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800880 /* mutex_unlock(&inode->i_mutex);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 if (rc)
882 CIFS_I(inode)->write_behind_rc = rc;
883 cFYI(1,("Oplock flush inode %p rc %d",inode,rc));
884
885 /* releasing a stale oplock after recent reconnection
886 of smb session using a now incorrect file
887 handle is not a data integrity issue but do
888 not bother sending an oplock release if session
889 to server still is disconnected since oplock
890 already released by the server in that case */
891 if(pTcon->tidStatus != CifsNeedReconnect) {
892 rc = CIFSSMBLock(0, pTcon, netfid,
893 0 /* len */ , 0 /* offset */, 0,
894 0, LOCKING_ANDX_OPLOCK_RELEASE,
895 0 /* wait flag */);
896 cFYI(1,("Oplock release rc = %d ",rc));
897 }
898 } else
899 spin_unlock(&GlobalMid_Lock);
Steve French68058e72005-10-10 10:34:22 -0700900 set_current_state(TASK_INTERRUPTIBLE);
901 schedule_timeout(1); /* yield in case q were corrupt */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 }
Steve French45af7a02006-04-21 22:52:25 +0000903 } while (!kthread_should_stop());
904
905 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906}
907
Steve French8d0d5092005-08-18 09:41:43 -0700908static int cifs_dnotify_thread(void * dummyarg)
909{
Steve French6ab16d22005-11-29 20:55:11 -0800910 struct list_head *tmp;
911 struct cifsSesInfo *ses;
912
Steve French8d0d5092005-08-18 09:41:43 -0700913 do {
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000914 if (try_to_freeze())
Steve French16abbec2005-08-30 13:10:14 -0700915 continue;
Steve French8d0d5092005-08-18 09:41:43 -0700916 set_current_state(TASK_INTERRUPTIBLE);
Steve French6ab16d22005-11-29 20:55:11 -0800917 schedule_timeout(15*HZ);
918 read_lock(&GlobalSMBSeslock);
919 /* check if any stuck requests that need
920 to be woken up and wakeq so the
921 thread can wake up and error out */
922 list_for_each(tmp, &GlobalSMBSessionList) {
923 ses = list_entry(tmp, struct cifsSesInfo,
924 cifsSessionList);
925 if(ses && ses->server &&
Steve French2a138ebb2005-11-29 21:22:19 -0800926 atomic_read(&ses->server->inFlight))
Steve French6ab16d22005-11-29 20:55:11 -0800927 wake_up_all(&ses->server->response_q);
928 }
929 read_unlock(&GlobalSMBSeslock);
Steve French45af7a02006-04-21 22:52:25 +0000930 } while (!kthread_should_stop());
931
932 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933}
934
935static int __init
936init_cifs(void)
937{
938 int rc = 0;
939#ifdef CONFIG_PROC_FS
940 cifs_proc_init();
941#endif
Steve French2cd646a2006-09-28 19:43:08 +0000942/* INIT_LIST_HEAD(&GlobalServerList);*/ /* BB not implemented yet */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 INIT_LIST_HEAD(&GlobalSMBSessionList);
944 INIT_LIST_HEAD(&GlobalTreeConnectionList);
945 INIT_LIST_HEAD(&GlobalOplock_Q);
Steve French4ca9c192005-10-10 19:52:13 -0700946#ifdef CONFIG_CIFS_EXPERIMENTAL
947 INIT_LIST_HEAD(&GlobalDnotifyReqList);
948 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
949#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950/*
951 * Initialize Global counters
952 */
953 atomic_set(&sesInfoAllocCount, 0);
954 atomic_set(&tconInfoAllocCount, 0);
955 atomic_set(&tcpSesAllocCount,0);
956 atomic_set(&tcpSesReconnectCount, 0);
957 atomic_set(&tconInfoReconnectCount, 0);
958
959 atomic_set(&bufAllocCount, 0);
Steve French4498eed52005-12-03 13:58:57 -0800960 atomic_set(&smBufAllocCount, 0);
961#ifdef CONFIG_CIFS_STATS2
962 atomic_set(&totBufAllocCount, 0);
963 atomic_set(&totSmBufAllocCount, 0);
964#endif /* CONFIG_CIFS_STATS2 */
965
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 atomic_set(&midCount, 0);
967 GlobalCurrentXid = 0;
968 GlobalTotalActiveXid = 0;
969 GlobalMaxActiveXid = 0;
Steve French2cd646a2006-09-28 19:43:08 +0000970 memset(Local_System_Name, 0, 15);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 rwlock_init(&GlobalSMBSeslock);
972 spin_lock_init(&GlobalMid_Lock);
973
974 if(cifs_max_pending < 2) {
975 cifs_max_pending = 2;
976 cFYI(1,("cifs_max_pending set to min of 2"));
977 } else if(cifs_max_pending > 256) {
978 cifs_max_pending = 256;
979 cFYI(1,("cifs_max_pending set to max of 256"));
980 }
981
982 rc = cifs_init_inodecache();
Steve French45af7a02006-04-21 22:52:25 +0000983 if (rc)
984 goto out_clean_proc;
985
986 rc = cifs_init_mids();
987 if (rc)
988 goto out_destroy_inodecache;
989
990 rc = cifs_init_request_bufs();
991 if (rc)
992 goto out_destroy_mids;
993
994 rc = register_filesystem(&cifs_fs_type);
995 if (rc)
996 goto out_destroy_request_bufs;
997
998 oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
999 if (IS_ERR(oplockThread)) {
1000 rc = PTR_ERR(oplockThread);
1001 cERROR(1,("error %d create oplock thread", rc));
1002 goto out_unregister_filesystem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 }
Steve French45af7a02006-04-21 22:52:25 +00001004
1005 dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
1006 if (IS_ERR(dnotifyThread)) {
1007 rc = PTR_ERR(dnotifyThread);
1008 cERROR(1,("error %d create dnotify thread", rc));
1009 goto out_stop_oplock_thread;
1010 }
1011
1012 return 0;
1013
1014 out_stop_oplock_thread:
1015 kthread_stop(oplockThread);
1016 out_unregister_filesystem:
1017 unregister_filesystem(&cifs_fs_type);
1018 out_destroy_request_bufs:
1019 cifs_destroy_request_bufs();
1020 out_destroy_mids:
1021 cifs_destroy_mids();
1022 out_destroy_inodecache:
1023 cifs_destroy_inodecache();
1024 out_clean_proc:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025#ifdef CONFIG_PROC_FS
1026 cifs_proc_clean();
1027#endif
1028 return rc;
1029}
1030
1031static void __exit
1032exit_cifs(void)
1033{
1034 cFYI(0, ("In unregister ie exit_cifs"));
1035#ifdef CONFIG_PROC_FS
1036 cifs_proc_clean();
1037#endif
1038 unregister_filesystem(&cifs_fs_type);
1039 cifs_destroy_inodecache();
1040 cifs_destroy_mids();
1041 cifs_destroy_request_bufs();
Steve French45af7a02006-04-21 22:52:25 +00001042 kthread_stop(oplockThread);
1043 kthread_stop(dnotifyThread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044}
1045
1046MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1047MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1048MODULE_DESCRIPTION
1049 ("VFS to access servers complying with the SNIA CIFS Specification e.g. Samba and Windows");
1050MODULE_VERSION(CIFS_VERSION);
1051module_init(init_cifs)
1052module_exit(exit_cifs)