4 * Copyright (C) International Business Machines Corp., 2002,2004
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * Common Internet FileSystem (CIFS) client
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.
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.
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
24 /* Note that BB means BUGBUG (ie something to fix eventually) */
26 #include <linux/module.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>
35 #include <linux/delay.h>
36 #include <linux/kthread.h>
37 #include <linux/freezer.h>
40 #define DECLARE_GLOBALS_HERE
42 #include "cifsproto.h"
43 #include "cifs_debug.h"
44 #include "cifs_fs_sb.h"
46 #define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
48 #ifdef CONFIG_CIFS_QUOTA
49 static struct quotactl_ops cifs_quotactl_ops;
55 unsigned int oplockEnabled = 1;
56 unsigned int experimEnabled = 0;
57 unsigned int linuxExtEnabled = 1;
58 unsigned int lookupCacheEnabled = 1;
59 unsigned int multiuser_mount = 0;
60 unsigned int extended_security = CIFSSEC_DEF;
61 /* unsigned int ntlmv2_support = 0; */
62 unsigned int sign_CIFS_PDUs = 1;
63 extern struct task_struct * oplockThread; /* remove sparse warning */
64 struct task_struct * oplockThread = NULL;
65 extern struct task_struct * dnotifyThread; /* remove sparse warning */
66 struct task_struct * dnotifyThread = NULL;
67 static const struct super_operations cifs_super_ops;
68 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
69 module_param(CIFSMaxBufSize, int, 0);
70 MODULE_PARM_DESC(CIFSMaxBufSize,"Network buffer size (not including header). Default: 16384 Range: 8192 to 130048");
71 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
72 module_param(cifs_min_rcv, int, 0);
73 MODULE_PARM_DESC(cifs_min_rcv,"Network buffers in pool. Default: 4 Range: 1 to 64");
74 unsigned int cifs_min_small = 30;
75 module_param(cifs_min_small, int, 0);
76 MODULE_PARM_DESC(cifs_min_small,"Small network buffers in pool. Default: 30 Range: 2 to 256");
77 unsigned int cifs_max_pending = CIFS_MAX_REQ;
78 module_param(cifs_max_pending, int, 0);
79 MODULE_PARM_DESC(cifs_max_pending,"Simultaneous requests to server. Default: 50 Range: 2 to 256");
81 extern mempool_t *cifs_sm_req_poolp;
82 extern mempool_t *cifs_req_poolp;
83 extern mempool_t *cifs_mid_poolp;
85 extern struct kmem_cache *cifs_oplock_cachep;
88 cifs_read_super(struct super_block *sb, void *data,
89 const char *devname, int silent)
92 struct cifs_sb_info *cifs_sb;
95 /* BB should we make this contingent on mount parm? */
96 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
97 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info),GFP_KERNEL);
98 cifs_sb = CIFS_SB(sb);
102 rc = cifs_mount(sb, cifs_sb, data, devname);
107 ("cifs_mount failed w/return code = %d", rc));
108 goto out_mount_failed;
111 sb->s_magic = CIFS_MAGIC_NUMBER;
112 sb->s_op = &cifs_super_ops;
113 /* if(cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
114 sb->s_blocksize = cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
115 #ifdef CONFIG_CIFS_QUOTA
116 sb->s_qcop = &cifs_quotactl_ops;
118 sb->s_blocksize = CIFS_MAX_MSGSIZE;
119 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
120 inode = iget(sb, ROOT_I);
127 sb->s_root = d_alloc_root(inode);
137 cERROR(1, ("cifs_read_super: get root inode failed"));
143 if(cifs_sb->local_nls)
144 unload_nls(cifs_sb->local_nls);
151 cifs_put_super(struct super_block *sb)
154 struct cifs_sb_info *cifs_sb;
156 cFYI(1, ("In cifs_put_super"));
157 cifs_sb = CIFS_SB(sb);
158 if(cifs_sb == NULL) {
159 cFYI(1,("Empty cifs superblock info passed to unmount"));
162 rc = cifs_umount(sb, cifs_sb);
164 cERROR(1, ("cifs_umount failed with return code %d", rc));
166 unload_nls(cifs_sb->local_nls);
172 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
174 struct super_block *sb = dentry->d_sb;
176 int rc = -EOPNOTSUPP;
177 struct cifs_sb_info *cifs_sb;
178 struct cifsTconInfo *pTcon;
182 cifs_sb = CIFS_SB(sb);
183 pTcon = cifs_sb->tcon;
185 buf->f_type = CIFS_MAGIC_NUMBER;
187 /* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */
188 buf->f_namelen = PATH_MAX; /* PATH_MAX may be too long - it would
189 presumably be total path, but note
190 that some servers (includinng Samba 3)
191 have a shorter maximum path */
192 buf->f_files = 0; /* undefined */
193 buf->f_ffree = 0; /* unlimited */
195 /* BB we could add a second check for a QFS Unix capability bit */
196 /* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */
197 if ((pTcon->ses->capabilities & CAP_UNIX) && (CIFS_POSIX_EXTENSIONS &
198 le64_to_cpu(pTcon->fsUnixInfo.Capability)))
199 rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf);
201 /* Only need to call the old QFSInfo if failed
204 if(pTcon->ses->capabilities & CAP_NT_SMBS)
205 rc = CIFSSMBQFSInfo(xid, pTcon, buf); /* not supported by OS2 */
207 /* Some old Windows servers also do not support level 103, retry with
208 older level one if old server failed the previous call or we
209 bypassed it because we detected that this was an older LANMAN sess */
211 rc = SMBOldQFSInfo(xid, pTcon, buf);
216 /* BB get from info in tcon struct at mount time call to QFSAttrInfo */
218 return 0; /* always return success? what if volume is no
222 static int cifs_permission(struct inode * inode, int mask, struct nameidata *nd)
224 struct cifs_sb_info *cifs_sb;
226 cifs_sb = CIFS_SB(inode->i_sb);
228 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
230 } else /* file mode might have been restricted at mount time
231 on the client (above and beyond ACL on servers) for
232 servers which do not support setting and viewing mode bits,
233 so allowing client to check permissions is useful */
234 return generic_permission(inode, mask, NULL);
237 static struct kmem_cache *cifs_inode_cachep;
238 static struct kmem_cache *cifs_req_cachep;
239 static struct kmem_cache *cifs_mid_cachep;
240 struct kmem_cache *cifs_oplock_cachep;
241 static struct kmem_cache *cifs_sm_req_cachep;
242 mempool_t *cifs_sm_req_poolp;
243 mempool_t *cifs_req_poolp;
244 mempool_t *cifs_mid_poolp;
246 static struct inode *
247 cifs_alloc_inode(struct super_block *sb)
249 struct cifsInodeInfo *cifs_inode;
250 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
253 cifs_inode->cifsAttrs = 0x20; /* default */
254 atomic_set(&cifs_inode->inUse, 0);
255 cifs_inode->time = 0;
256 /* Until the file is open and we have gotten oplock
257 info back from the server, can not assume caching of
258 file data or metadata */
259 cifs_inode->clientCanCacheRead = FALSE;
260 cifs_inode->clientCanCacheAll = FALSE;
261 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
263 /* Can not set i_flags here - they get immediately overwritten
264 to zero by the VFS */
265 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
266 INIT_LIST_HEAD(&cifs_inode->openFileList);
267 return &cifs_inode->vfs_inode;
271 cifs_destroy_inode(struct inode *inode)
273 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
277 * cifs_show_options() is for displaying mount options in /proc/mounts.
278 * Not all settable options are displayed but most of the important
282 cifs_show_options(struct seq_file *s, struct vfsmount *m)
284 struct cifs_sb_info *cifs_sb;
286 cifs_sb = CIFS_SB(m->mnt_sb);
290 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
291 if (cifs_sb->tcon->ses) {
292 if (cifs_sb->tcon->ses->userName)
293 seq_printf(s, ",username=%s",
294 cifs_sb->tcon->ses->userName);
295 if(cifs_sb->tcon->ses->domainName)
296 seq_printf(s, ",domain=%s",
297 cifs_sb->tcon->ses->domainName);
300 seq_printf(s, ",rsize=%d",cifs_sb->rsize);
301 seq_printf(s, ",wsize=%d",cifs_sb->wsize);
306 #ifdef CONFIG_CIFS_QUOTA
307 int cifs_xquota_set(struct super_block * sb, int quota_type, qid_t qid,
308 struct fs_disk_quota * pdquota)
312 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
313 struct cifsTconInfo *pTcon;
316 pTcon = cifs_sb->tcon;
323 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
332 int cifs_xquota_get(struct super_block * sb, int quota_type, qid_t qid,
333 struct fs_disk_quota * pdquota)
337 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
338 struct cifsTconInfo *pTcon;
341 pTcon = cifs_sb->tcon;
347 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
356 int cifs_xstate_set(struct super_block * sb, unsigned int flags, int operation)
360 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
361 struct cifsTconInfo *pTcon;
364 pTcon = cifs_sb->tcon;
370 cFYI(1,("flags: 0x%x operation: 0x%x",flags,operation));
379 int cifs_xstate_get(struct super_block * sb, struct fs_quota_stat *qstats)
383 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
384 struct cifsTconInfo *pTcon;
387 pTcon = cifs_sb->tcon;
393 cFYI(1,("pqstats %p",qstats));
402 static struct quotactl_ops cifs_quotactl_ops = {
403 .set_xquota = cifs_xquota_set,
404 .get_xquota = cifs_xquota_set,
405 .set_xstate = cifs_xstate_set,
406 .get_xstate = cifs_xstate_get,
410 static void cifs_umount_begin(struct vfsmount * vfsmnt, int flags)
412 struct cifs_sb_info *cifs_sb;
413 struct cifsTconInfo * tcon;
415 if (!(flags & MNT_FORCE))
417 cifs_sb = CIFS_SB(vfsmnt->mnt_sb);
421 tcon = cifs_sb->tcon;
424 down(&tcon->tconSem);
425 if (atomic_read(&tcon->useCount) == 1)
426 tcon->tidStatus = CifsExiting;
429 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
430 /* cancel_notify_requests(tcon); */
431 if(tcon->ses && tcon->ses->server)
433 cFYI(1,("wake up tasks now - umount begin not complete"));
434 wake_up_all(&tcon->ses->server->request_q);
435 wake_up_all(&tcon->ses->server->response_q);
436 msleep(1); /* yield */
437 /* we have to kick the requests once more */
438 wake_up_all(&tcon->ses->server->response_q);
441 /* BB FIXME - finish add checks for tidStatus BB */
446 #ifdef CONFIG_CIFS_STATS2
447 static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
454 static int cifs_remount(struct super_block *sb, int *flags, char *data)
456 *flags |= MS_NODIRATIME;
460 static const struct super_operations cifs_super_ops = {
461 .read_inode = cifs_read_inode,
462 .put_super = cifs_put_super,
463 .statfs = cifs_statfs,
464 .alloc_inode = cifs_alloc_inode,
465 .destroy_inode = cifs_destroy_inode,
466 /* .drop_inode = generic_delete_inode,
467 .delete_inode = cifs_delete_inode, *//* Do not need the above two functions
468 unless later we add lazy close of inodes or unless the kernel forgets to call
469 us with the same number of releases (closes) as opens */
470 .show_options = cifs_show_options,
471 .umount_begin = cifs_umount_begin,
472 .remount_fs = cifs_remount,
473 #ifdef CONFIG_CIFS_STATS2
474 .show_stats = cifs_show_stats,
479 cifs_get_sb(struct file_system_type *fs_type,
480 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
483 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
485 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
492 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
494 up_write(&sb->s_umount);
495 deactivate_super(sb);
498 sb->s_flags |= MS_ACTIVE;
499 return simple_set_mnt(mnt, sb);
502 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
503 unsigned long nr_segs, loff_t pos)
505 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
508 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
509 if (!CIFS_I(inode)->clientCanCacheAll)
510 filemap_fdatawrite(inode->i_mapping);
514 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
516 /* origin == SEEK_END => we must revalidate the cached file length */
517 if (origin == SEEK_END) {
520 /* some applications poll for the file length in this strange
521 way so we must seek to end on non-oplocked files by
522 setting the revalidate time to zero */
523 if(file->f_path.dentry->d_inode)
524 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
526 retval = cifs_revalidate(file->f_path.dentry);
528 return (loff_t)retval;
530 return remote_llseek(file, offset, origin);
533 static struct file_system_type cifs_fs_type = {
534 .owner = THIS_MODULE,
536 .get_sb = cifs_get_sb,
537 .kill_sb = kill_anon_super,
540 const struct inode_operations cifs_dir_inode_ops = {
541 .create = cifs_create,
542 .lookup = cifs_lookup,
543 .getattr = cifs_getattr,
544 .unlink = cifs_unlink,
545 .link = cifs_hardlink,
548 .rename = cifs_rename,
549 .permission = cifs_permission,
550 /* revalidate:cifs_revalidate, */
551 .setattr = cifs_setattr,
552 .symlink = cifs_symlink,
554 #ifdef CONFIG_CIFS_XATTR
555 .setxattr = cifs_setxattr,
556 .getxattr = cifs_getxattr,
557 .listxattr = cifs_listxattr,
558 .removexattr = cifs_removexattr,
562 const struct inode_operations cifs_file_inode_ops = {
563 /* revalidate:cifs_revalidate, */
564 .setattr = cifs_setattr,
565 .getattr = cifs_getattr, /* do we need this anymore? */
566 .rename = cifs_rename,
567 .permission = cifs_permission,
568 #ifdef CONFIG_CIFS_XATTR
569 .setxattr = cifs_setxattr,
570 .getxattr = cifs_getxattr,
571 .listxattr = cifs_listxattr,
572 .removexattr = cifs_removexattr,
576 const struct inode_operations cifs_symlink_inode_ops = {
577 .readlink = generic_readlink,
578 .follow_link = cifs_follow_link,
579 .put_link = cifs_put_link,
580 .permission = cifs_permission,
581 /* BB add the following two eventually */
582 /* revalidate: cifs_revalidate,
583 setattr: cifs_notify_change, *//* BB do we need notify change */
584 #ifdef CONFIG_CIFS_XATTR
585 .setxattr = cifs_setxattr,
586 .getxattr = cifs_getxattr,
587 .listxattr = cifs_listxattr,
588 .removexattr = cifs_removexattr,
592 const struct file_operations cifs_file_ops = {
593 .read = do_sync_read,
594 .write = do_sync_write,
595 .aio_read = generic_file_aio_read,
596 .aio_write = cifs_file_aio_write,
598 .release = cifs_close,
602 .mmap = cifs_file_mmap,
603 .sendfile = generic_file_sendfile,
604 .llseek = cifs_llseek,
605 #ifdef CONFIG_CIFS_POSIX
607 #endif /* CONFIG_CIFS_POSIX */
609 #ifdef CONFIG_CIFS_EXPERIMENTAL
610 .dir_notify = cifs_dir_notify,
611 #endif /* CONFIG_CIFS_EXPERIMENTAL */
614 const struct file_operations cifs_file_direct_ops = {
615 /* no mmap, no aio, no readv -
616 BB reevaluate whether they can be done with directio, no cache */
617 .read = cifs_user_read,
618 .write = cifs_user_write,
620 .release = cifs_close,
624 .sendfile = generic_file_sendfile, /* BB removeme BB */
625 #ifdef CONFIG_CIFS_POSIX
627 #endif /* CONFIG_CIFS_POSIX */
628 .llseek = cifs_llseek,
629 #ifdef CONFIG_CIFS_EXPERIMENTAL
630 .dir_notify = cifs_dir_notify,
631 #endif /* CONFIG_CIFS_EXPERIMENTAL */
633 const struct file_operations cifs_file_nobrl_ops = {
634 .read = do_sync_read,
635 .write = do_sync_write,
636 .aio_read = generic_file_aio_read,
637 .aio_write = cifs_file_aio_write,
639 .release = cifs_close,
642 .mmap = cifs_file_mmap,
643 .sendfile = generic_file_sendfile,
644 .llseek = cifs_llseek,
645 #ifdef CONFIG_CIFS_POSIX
647 #endif /* CONFIG_CIFS_POSIX */
649 #ifdef CONFIG_CIFS_EXPERIMENTAL
650 .dir_notify = cifs_dir_notify,
651 #endif /* CONFIG_CIFS_EXPERIMENTAL */
654 const struct file_operations cifs_file_direct_nobrl_ops = {
655 /* no mmap, no aio, no readv -
656 BB reevaluate whether they can be done with directio, no cache */
657 .read = cifs_user_read,
658 .write = cifs_user_write,
660 .release = cifs_close,
663 .sendfile = generic_file_sendfile, /* BB removeme BB */
664 #ifdef CONFIG_CIFS_POSIX
666 #endif /* CONFIG_CIFS_POSIX */
667 .llseek = cifs_llseek,
668 #ifdef CONFIG_CIFS_EXPERIMENTAL
669 .dir_notify = cifs_dir_notify,
670 #endif /* CONFIG_CIFS_EXPERIMENTAL */
673 const struct file_operations cifs_dir_ops = {
674 .readdir = cifs_readdir,
675 .release = cifs_closedir,
676 .read = generic_read_dir,
677 #ifdef CONFIG_CIFS_EXPERIMENTAL
678 .dir_notify = cifs_dir_notify,
679 #endif /* CONFIG_CIFS_EXPERIMENTAL */
684 cifs_init_once(void *inode, struct kmem_cache * cachep, unsigned long flags)
686 struct cifsInodeInfo *cifsi = inode;
688 if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
689 SLAB_CTOR_CONSTRUCTOR) {
690 inode_init_once(&cifsi->vfs_inode);
691 INIT_LIST_HEAD(&cifsi->lockList);
696 cifs_init_inodecache(void)
698 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
699 sizeof (struct cifsInodeInfo),
700 0, (SLAB_RECLAIM_ACCOUNT|
702 cifs_init_once, NULL);
703 if (cifs_inode_cachep == NULL)
710 cifs_destroy_inodecache(void)
712 kmem_cache_destroy(cifs_inode_cachep);
716 cifs_init_request_bufs(void)
718 if(CIFSMaxBufSize < 8192) {
719 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
720 Unicode path name has to fit in any SMB/CIFS path based frames */
721 CIFSMaxBufSize = 8192;
722 } else if (CIFSMaxBufSize > 1024*127) {
723 CIFSMaxBufSize = 1024 * 127;
725 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
727 /* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
728 cifs_req_cachep = kmem_cache_create("cifs_request",
730 MAX_CIFS_HDR_SIZE, 0,
731 SLAB_HWCACHE_ALIGN, NULL, NULL);
732 if (cifs_req_cachep == NULL)
737 else if (cifs_min_rcv > 64) {
739 cERROR(1,("cifs_min_rcv set to maximum (64)"));
742 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
745 if(cifs_req_poolp == NULL) {
746 kmem_cache_destroy(cifs_req_cachep);
749 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
750 almost all handle based requests (but not write response, nor is it
751 sufficient for path based requests). A smaller size would have
752 been more efficient (compacting multiple slab items on one 4k page)
753 for the case in which debug was on, but this larger size allows
754 more SMBs to use small buffer alloc and is still much more
755 efficient to alloc 1 per page off the slab compared to 17K (5page)
756 alloc of large cifs buffers even when page debugging is on */
757 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
758 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
760 if (cifs_sm_req_cachep == NULL) {
761 mempool_destroy(cifs_req_poolp);
762 kmem_cache_destroy(cifs_req_cachep);
766 if(cifs_min_small < 2)
768 else if (cifs_min_small > 256) {
769 cifs_min_small = 256;
770 cFYI(1,("cifs_min_small set to maximum (256)"));
773 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
776 if(cifs_sm_req_poolp == NULL) {
777 mempool_destroy(cifs_req_poolp);
778 kmem_cache_destroy(cifs_req_cachep);
779 kmem_cache_destroy(cifs_sm_req_cachep);
787 cifs_destroy_request_bufs(void)
789 mempool_destroy(cifs_req_poolp);
790 kmem_cache_destroy(cifs_req_cachep);
791 mempool_destroy(cifs_sm_req_poolp);
792 kmem_cache_destroy(cifs_sm_req_cachep);
798 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
799 sizeof (struct mid_q_entry), 0,
800 SLAB_HWCACHE_ALIGN, NULL, NULL);
801 if (cifs_mid_cachep == NULL)
804 /* 3 is a reasonable minimum number of simultaneous operations */
805 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
806 if(cifs_mid_poolp == NULL) {
807 kmem_cache_destroy(cifs_mid_cachep);
811 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
812 sizeof (struct oplock_q_entry), 0,
813 SLAB_HWCACHE_ALIGN, NULL, NULL);
814 if (cifs_oplock_cachep == NULL) {
815 kmem_cache_destroy(cifs_mid_cachep);
816 mempool_destroy(cifs_mid_poolp);
824 cifs_destroy_mids(void)
826 mempool_destroy(cifs_mid_poolp);
827 kmem_cache_destroy(cifs_mid_cachep);
828 kmem_cache_destroy(cifs_oplock_cachep);
831 static int cifs_oplock_thread(void * dummyarg)
833 struct oplock_q_entry * oplock_item;
834 struct cifsTconInfo *pTcon;
835 struct inode * inode;
843 spin_lock(&GlobalMid_Lock);
844 if(list_empty(&GlobalOplock_Q)) {
845 spin_unlock(&GlobalMid_Lock);
846 set_current_state(TASK_INTERRUPTIBLE);
847 schedule_timeout(39*HZ);
849 oplock_item = list_entry(GlobalOplock_Q.next,
850 struct oplock_q_entry, qhead);
852 cFYI(1,("found oplock item to write out"));
853 pTcon = oplock_item->tcon;
854 inode = oplock_item->pinode;
855 netfid = oplock_item->netfid;
856 spin_unlock(&GlobalMid_Lock);
857 DeleteOplockQEntry(oplock_item);
858 /* can not grab inode sem here since it would
859 deadlock when oplock received on delete
860 since vfs_unlink holds the i_mutex across
862 /* mutex_lock(&inode->i_mutex);*/
863 if (S_ISREG(inode->i_mode)) {
864 rc = filemap_fdatawrite(inode->i_mapping);
865 if(CIFS_I(inode)->clientCanCacheRead == 0) {
866 filemap_fdatawait(inode->i_mapping);
867 invalidate_remote_inode(inode);
871 /* mutex_unlock(&inode->i_mutex);*/
873 CIFS_I(inode)->write_behind_rc = rc;
874 cFYI(1,("Oplock flush inode %p rc %d",inode,rc));
876 /* releasing a stale oplock after recent reconnection
877 of smb session using a now incorrect file
878 handle is not a data integrity issue but do
879 not bother sending an oplock release if session
880 to server still is disconnected since oplock
881 already released by the server in that case */
882 if(pTcon->tidStatus != CifsNeedReconnect) {
883 rc = CIFSSMBLock(0, pTcon, netfid,
884 0 /* len */ , 0 /* offset */, 0,
885 0, LOCKING_ANDX_OPLOCK_RELEASE,
887 cFYI(1,("Oplock release rc = %d ",rc));
890 spin_unlock(&GlobalMid_Lock);
891 set_current_state(TASK_INTERRUPTIBLE);
892 schedule_timeout(1); /* yield in case q were corrupt */
894 } while (!kthread_should_stop());
899 static int cifs_dnotify_thread(void * dummyarg)
901 struct list_head *tmp;
902 struct cifsSesInfo *ses;
907 set_current_state(TASK_INTERRUPTIBLE);
908 schedule_timeout(15*HZ);
909 read_lock(&GlobalSMBSeslock);
910 /* check if any stuck requests that need
911 to be woken up and wakeq so the
912 thread can wake up and error out */
913 list_for_each(tmp, &GlobalSMBSessionList) {
914 ses = list_entry(tmp, struct cifsSesInfo,
916 if(ses && ses->server &&
917 atomic_read(&ses->server->inFlight))
918 wake_up_all(&ses->server->response_q);
920 read_unlock(&GlobalSMBSeslock);
921 } while (!kthread_should_stop());
930 #ifdef CONFIG_PROC_FS
933 /* INIT_LIST_HEAD(&GlobalServerList);*/ /* BB not implemented yet */
934 INIT_LIST_HEAD(&GlobalSMBSessionList);
935 INIT_LIST_HEAD(&GlobalTreeConnectionList);
936 INIT_LIST_HEAD(&GlobalOplock_Q);
937 #ifdef CONFIG_CIFS_EXPERIMENTAL
938 INIT_LIST_HEAD(&GlobalDnotifyReqList);
939 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
942 * Initialize Global counters
944 atomic_set(&sesInfoAllocCount, 0);
945 atomic_set(&tconInfoAllocCount, 0);
946 atomic_set(&tcpSesAllocCount,0);
947 atomic_set(&tcpSesReconnectCount, 0);
948 atomic_set(&tconInfoReconnectCount, 0);
950 atomic_set(&bufAllocCount, 0);
951 atomic_set(&smBufAllocCount, 0);
952 #ifdef CONFIG_CIFS_STATS2
953 atomic_set(&totBufAllocCount, 0);
954 atomic_set(&totSmBufAllocCount, 0);
955 #endif /* CONFIG_CIFS_STATS2 */
957 atomic_set(&midCount, 0);
958 GlobalCurrentXid = 0;
959 GlobalTotalActiveXid = 0;
960 GlobalMaxActiveXid = 0;
961 memset(Local_System_Name, 0, 15);
962 rwlock_init(&GlobalSMBSeslock);
963 spin_lock_init(&GlobalMid_Lock);
965 if(cifs_max_pending < 2) {
966 cifs_max_pending = 2;
967 cFYI(1,("cifs_max_pending set to min of 2"));
968 } else if(cifs_max_pending > 256) {
969 cifs_max_pending = 256;
970 cFYI(1,("cifs_max_pending set to max of 256"));
973 rc = cifs_init_inodecache();
977 rc = cifs_init_mids();
979 goto out_destroy_inodecache;
981 rc = cifs_init_request_bufs();
983 goto out_destroy_mids;
985 rc = register_filesystem(&cifs_fs_type);
987 goto out_destroy_request_bufs;
989 oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
990 if (IS_ERR(oplockThread)) {
991 rc = PTR_ERR(oplockThread);
992 cERROR(1,("error %d create oplock thread", rc));
993 goto out_unregister_filesystem;
996 dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
997 if (IS_ERR(dnotifyThread)) {
998 rc = PTR_ERR(dnotifyThread);
999 cERROR(1,("error %d create dnotify thread", rc));
1000 goto out_stop_oplock_thread;
1005 out_stop_oplock_thread:
1006 kthread_stop(oplockThread);
1007 out_unregister_filesystem:
1008 unregister_filesystem(&cifs_fs_type);
1009 out_destroy_request_bufs:
1010 cifs_destroy_request_bufs();
1012 cifs_destroy_mids();
1013 out_destroy_inodecache:
1014 cifs_destroy_inodecache();
1016 #ifdef CONFIG_PROC_FS
1025 cFYI(0, ("In unregister ie exit_cifs"));
1026 #ifdef CONFIG_PROC_FS
1029 unregister_filesystem(&cifs_fs_type);
1030 cifs_destroy_inodecache();
1031 cifs_destroy_mids();
1032 cifs_destroy_request_bufs();
1033 kthread_stop(oplockThread);
1034 kthread_stop(dnotifyThread);
1037 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1038 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1040 ("VFS to access servers complying with the SNIA CIFS Specification e.g. Samba and Windows");
1041 MODULE_VERSION(CIFS_VERSION);
1042 module_init(init_cifs)
1043 module_exit(exit_cifs)