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>
39 #define DECLARE_GLOBALS_HERE
41 #include "cifsproto.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
45 #define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
47 #ifdef CONFIG_CIFS_QUOTA
48 static struct quotactl_ops cifs_quotactl_ops;
54 unsigned int oplockEnabled = 1;
55 unsigned int experimEnabled = 0;
56 unsigned int linuxExtEnabled = 1;
57 unsigned int lookupCacheEnabled = 1;
58 unsigned int multiuser_mount = 0;
59 unsigned int extended_security = CIFSSEC_DEF;
60 /* unsigned int ntlmv2_support = 0; */
61 unsigned int sign_CIFS_PDUs = 1;
62 extern struct task_struct * oplockThread; /* remove sparse warning */
63 struct task_struct * oplockThread = NULL;
64 extern struct task_struct * dnotifyThread; /* remove sparse warning */
65 struct task_struct * dnotifyThread = NULL;
66 static struct super_operations cifs_super_ops;
67 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
68 module_param(CIFSMaxBufSize, int, 0);
69 MODULE_PARM_DESC(CIFSMaxBufSize,"Network buffer size (not including header). Default: 16384 Range: 8192 to 130048");
70 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
71 module_param(cifs_min_rcv, int, 0);
72 MODULE_PARM_DESC(cifs_min_rcv,"Network buffers in pool. Default: 4 Range: 1 to 64");
73 unsigned int cifs_min_small = 30;
74 module_param(cifs_min_small, int, 0);
75 MODULE_PARM_DESC(cifs_min_small,"Small network buffers in pool. Default: 30 Range: 2 to 256");
76 unsigned int cifs_max_pending = CIFS_MAX_REQ;
77 module_param(cifs_max_pending, int, 0);
78 MODULE_PARM_DESC(cifs_max_pending,"Simultaneous requests to server. Default: 50 Range: 2 to 256");
80 extern mempool_t *cifs_sm_req_poolp;
81 extern mempool_t *cifs_req_poolp;
82 extern mempool_t *cifs_mid_poolp;
84 extern kmem_cache_t *cifs_oplock_cachep;
87 cifs_read_super(struct super_block *sb, void *data,
88 const char *devname, int silent)
91 struct cifs_sb_info *cifs_sb;
94 sb->s_flags |= MS_NODIRATIME; /* and probably even noatime */
95 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info),GFP_KERNEL);
96 cifs_sb = CIFS_SB(sb);
100 rc = cifs_mount(sb, cifs_sb, data, devname);
105 ("cifs_mount failed w/return code = %d", rc));
106 goto out_mount_failed;
109 sb->s_magic = CIFS_MAGIC_NUMBER;
110 sb->s_op = &cifs_super_ops;
111 /* if(cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
112 sb->s_blocksize = cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
113 #ifdef CONFIG_CIFS_QUOTA
114 sb->s_qcop = &cifs_quotactl_ops;
116 sb->s_blocksize = CIFS_MAX_MSGSIZE;
117 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
118 inode = iget(sb, ROOT_I);
125 sb->s_root = d_alloc_root(inode);
135 cERROR(1, ("cifs_read_super: get root inode failed"));
141 if(cifs_sb->local_nls)
142 unload_nls(cifs_sb->local_nls);
149 cifs_put_super(struct super_block *sb)
152 struct cifs_sb_info *cifs_sb;
154 cFYI(1, ("In cifs_put_super"));
155 cifs_sb = CIFS_SB(sb);
156 if(cifs_sb == NULL) {
157 cFYI(1,("Empty cifs superblock info passed to unmount"));
160 rc = cifs_umount(sb, cifs_sb);
162 cERROR(1, ("cifs_umount failed with return code %d", rc));
164 unload_nls(cifs_sb->local_nls);
170 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
172 struct super_block *sb = dentry->d_sb;
174 int rc = -EOPNOTSUPP;
175 struct cifs_sb_info *cifs_sb;
176 struct cifsTconInfo *pTcon;
180 cifs_sb = CIFS_SB(sb);
181 pTcon = cifs_sb->tcon;
183 buf->f_type = CIFS_MAGIC_NUMBER;
185 /* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */
186 buf->f_namelen = PATH_MAX; /* PATH_MAX may be too long - it would
187 presumably be total path, but note
188 that some servers (includinng Samba 3)
189 have a shorter maximum path */
190 buf->f_files = 0; /* undefined */
191 buf->f_ffree = 0; /* unlimited */
193 /* BB we could add a second check for a QFS Unix capability bit */
194 /* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */
195 if ((pTcon->ses->capabilities & CAP_UNIX) && (CIFS_POSIX_EXTENSIONS &
196 le64_to_cpu(pTcon->fsUnixInfo.Capability)))
197 rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf);
199 /* Only need to call the old QFSInfo if failed
202 rc = CIFSSMBQFSInfo(xid, pTcon, buf);
204 /* Old Windows servers do not support level 103, retry with level
205 one if old server failed the previous call */
207 rc = SMBOldQFSInfo(xid, pTcon, buf);
212 /* BB get from info in tcon struct at mount time call to QFSAttrInfo */
214 return 0; /* always return success? what if volume is no
218 static int cifs_permission(struct inode * inode, int mask, struct nameidata *nd)
220 struct cifs_sb_info *cifs_sb;
222 cifs_sb = CIFS_SB(inode->i_sb);
224 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
226 } else /* file mode might have been restricted at mount time
227 on the client (above and beyond ACL on servers) for
228 servers which do not support setting and viewing mode bits,
229 so allowing client to check permissions is useful */
230 return generic_permission(inode, mask, NULL);
233 static kmem_cache_t *cifs_inode_cachep;
234 static kmem_cache_t *cifs_req_cachep;
235 static kmem_cache_t *cifs_mid_cachep;
236 kmem_cache_t *cifs_oplock_cachep;
237 static kmem_cache_t *cifs_sm_req_cachep;
238 mempool_t *cifs_sm_req_poolp;
239 mempool_t *cifs_req_poolp;
240 mempool_t *cifs_mid_poolp;
242 static struct inode *
243 cifs_alloc_inode(struct super_block *sb)
245 struct cifsInodeInfo *cifs_inode;
246 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, SLAB_KERNEL);
249 cifs_inode->cifsAttrs = 0x20; /* default */
250 atomic_set(&cifs_inode->inUse, 0);
251 cifs_inode->time = 0;
252 /* Until the file is open and we have gotten oplock
253 info back from the server, can not assume caching of
254 file data or metadata */
255 cifs_inode->clientCanCacheRead = FALSE;
256 cifs_inode->clientCanCacheAll = FALSE;
257 cifs_inode->vfs_inode.i_blksize = CIFS_MAX_MSGSIZE;
258 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
259 cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;
260 INIT_LIST_HEAD(&cifs_inode->openFileList);
261 return &cifs_inode->vfs_inode;
265 cifs_destroy_inode(struct inode *inode)
267 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
271 * cifs_show_options() is for displaying mount options in /proc/mounts.
272 * Not all settable options are displayed but most of the important
276 cifs_show_options(struct seq_file *s, struct vfsmount *m)
278 struct cifs_sb_info *cifs_sb;
280 cifs_sb = CIFS_SB(m->mnt_sb);
284 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
285 if (cifs_sb->tcon->ses) {
286 if (cifs_sb->tcon->ses->userName)
287 seq_printf(s, ",username=%s",
288 cifs_sb->tcon->ses->userName);
289 if(cifs_sb->tcon->ses->domainName)
290 seq_printf(s, ",domain=%s",
291 cifs_sb->tcon->ses->domainName);
294 seq_printf(s, ",rsize=%d",cifs_sb->rsize);
295 seq_printf(s, ",wsize=%d",cifs_sb->wsize);
300 #ifdef CONFIG_CIFS_QUOTA
301 int cifs_xquota_set(struct super_block * sb, int quota_type, qid_t qid,
302 struct fs_disk_quota * pdquota)
306 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
307 struct cifsTconInfo *pTcon;
310 pTcon = cifs_sb->tcon;
317 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
326 int cifs_xquota_get(struct super_block * sb, int quota_type, qid_t qid,
327 struct fs_disk_quota * pdquota)
331 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
332 struct cifsTconInfo *pTcon;
335 pTcon = cifs_sb->tcon;
341 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
350 int cifs_xstate_set(struct super_block * sb, unsigned int flags, int operation)
354 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
355 struct cifsTconInfo *pTcon;
358 pTcon = cifs_sb->tcon;
364 cFYI(1,("flags: 0x%x operation: 0x%x",flags,operation));
373 int cifs_xstate_get(struct super_block * sb, struct fs_quota_stat *qstats)
377 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
378 struct cifsTconInfo *pTcon;
381 pTcon = cifs_sb->tcon;
387 cFYI(1,("pqstats %p",qstats));
396 static struct quotactl_ops cifs_quotactl_ops = {
397 .set_xquota = cifs_xquota_set,
398 .get_xquota = cifs_xquota_set,
399 .set_xstate = cifs_xstate_set,
400 .get_xstate = cifs_xstate_get,
404 static void cifs_umount_begin(struct vfsmount * vfsmnt, int flags)
406 struct cifs_sb_info *cifs_sb;
407 struct cifsTconInfo * tcon;
409 if (!(flags & MNT_FORCE))
411 cifs_sb = CIFS_SB(vfsmnt->mnt_sb);
415 tcon = cifs_sb->tcon;
418 down(&tcon->tconSem);
419 if (atomic_read(&tcon->useCount) == 1)
420 tcon->tidStatus = CifsExiting;
423 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
424 /* cancel_notify_requests(tcon); */
425 if(tcon->ses && tcon->ses->server)
427 cFYI(1,("wake up tasks now - umount begin not complete"));
428 wake_up_all(&tcon->ses->server->request_q);
429 wake_up_all(&tcon->ses->server->response_q);
430 msleep(1); /* yield */
431 /* we have to kick the requests once more */
432 wake_up_all(&tcon->ses->server->response_q);
435 /* BB FIXME - finish add checks for tidStatus BB */
440 #ifdef CONFIG_CIFS_STATS2
441 static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
448 static int cifs_remount(struct super_block *sb, int *flags, char *data)
450 *flags |= MS_NODIRATIME;
454 static struct super_operations cifs_super_ops = {
455 .read_inode = cifs_read_inode,
456 .put_super = cifs_put_super,
457 .statfs = cifs_statfs,
458 .alloc_inode = cifs_alloc_inode,
459 .destroy_inode = cifs_destroy_inode,
460 /* .drop_inode = generic_delete_inode,
461 .delete_inode = cifs_delete_inode, *//* Do not need the above two functions
462 unless later we add lazy close of inodes or unless the kernel forgets to call
463 us with the same number of releases (closes) as opens */
464 .show_options = cifs_show_options,
465 .umount_begin = cifs_umount_begin,
466 .remount_fs = cifs_remount,
467 #ifdef CONFIG_CIFS_STATS2
473 cifs_get_sb(struct file_system_type *fs_type,
474 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
477 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
479 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
486 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
488 up_write(&sb->s_umount);
489 deactivate_super(sb);
492 sb->s_flags |= MS_ACTIVE;
493 return simple_set_mnt(mnt, sb);
496 static ssize_t cifs_file_writev(struct file *file, const struct iovec *iov,
497 unsigned long nr_segs, loff_t *ppos)
499 struct inode *inode = file->f_dentry->d_inode;
502 written = generic_file_writev(file, iov, nr_segs, ppos);
503 if (!CIFS_I(inode)->clientCanCacheAll)
504 filemap_fdatawrite(inode->i_mapping);
508 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const char __user *buf,
509 size_t count, loff_t pos)
511 struct inode *inode = iocb->ki_filp->f_dentry->d_inode;
514 written = generic_file_aio_write(iocb, buf, count, pos);
515 if (!CIFS_I(inode)->clientCanCacheAll)
516 filemap_fdatawrite(inode->i_mapping);
520 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
522 /* origin == SEEK_END => we must revalidate the cached file length */
523 if (origin == SEEK_END) {
524 int retval = cifs_revalidate(file->f_dentry);
526 return (loff_t)retval;
528 return remote_llseek(file, offset, origin);
531 static struct file_system_type cifs_fs_type = {
532 .owner = THIS_MODULE,
534 .get_sb = cifs_get_sb,
535 .kill_sb = kill_anon_super,
538 struct inode_operations cifs_dir_inode_ops = {
539 .create = cifs_create,
540 .lookup = cifs_lookup,
541 .getattr = cifs_getattr,
542 .unlink = cifs_unlink,
543 .link = cifs_hardlink,
546 .rename = cifs_rename,
547 .permission = cifs_permission,
548 /* revalidate:cifs_revalidate, */
549 .setattr = cifs_setattr,
550 .symlink = cifs_symlink,
552 #ifdef CONFIG_CIFS_XATTR
553 .setxattr = cifs_setxattr,
554 .getxattr = cifs_getxattr,
555 .listxattr = cifs_listxattr,
556 .removexattr = cifs_removexattr,
560 struct inode_operations cifs_file_inode_ops = {
561 /* revalidate:cifs_revalidate, */
562 .setattr = cifs_setattr,
563 .getattr = cifs_getattr, /* do we need this anymore? */
564 .rename = cifs_rename,
565 .permission = cifs_permission,
566 #ifdef CONFIG_CIFS_XATTR
567 .setxattr = cifs_setxattr,
568 .getxattr = cifs_getxattr,
569 .listxattr = cifs_listxattr,
570 .removexattr = cifs_removexattr,
574 struct inode_operations cifs_symlink_inode_ops = {
575 .readlink = generic_readlink,
576 .follow_link = cifs_follow_link,
577 .put_link = cifs_put_link,
578 .permission = cifs_permission,
579 /* BB add the following two eventually */
580 /* revalidate: cifs_revalidate,
581 setattr: cifs_notify_change, *//* BB do we need notify change */
582 #ifdef CONFIG_CIFS_XATTR
583 .setxattr = cifs_setxattr,
584 .getxattr = cifs_getxattr,
585 .listxattr = cifs_listxattr,
586 .removexattr = cifs_removexattr,
590 const struct file_operations cifs_file_ops = {
591 .read = do_sync_read,
592 .write = do_sync_write,
593 .readv = generic_file_readv,
594 .writev = cifs_file_writev,
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 .readv = generic_file_readv,
637 .writev = cifs_file_writev,
638 .aio_read = generic_file_aio_read,
639 .aio_write = cifs_file_aio_write,
641 .release = cifs_close,
644 .mmap = cifs_file_mmap,
645 .sendfile = generic_file_sendfile,
646 .llseek = cifs_llseek,
647 #ifdef CONFIG_CIFS_POSIX
649 #endif /* CONFIG_CIFS_POSIX */
651 #ifdef CONFIG_CIFS_EXPERIMENTAL
652 .dir_notify = cifs_dir_notify,
653 #endif /* CONFIG_CIFS_EXPERIMENTAL */
656 const struct file_operations cifs_file_direct_nobrl_ops = {
657 /* no mmap, no aio, no readv -
658 BB reevaluate whether they can be done with directio, no cache */
659 .read = cifs_user_read,
660 .write = cifs_user_write,
662 .release = cifs_close,
665 .sendfile = generic_file_sendfile, /* BB removeme BB */
666 #ifdef CONFIG_CIFS_POSIX
668 #endif /* CONFIG_CIFS_POSIX */
669 .llseek = cifs_llseek,
670 #ifdef CONFIG_CIFS_EXPERIMENTAL
671 .dir_notify = cifs_dir_notify,
672 #endif /* CONFIG_CIFS_EXPERIMENTAL */
675 const struct file_operations cifs_dir_ops = {
676 .readdir = cifs_readdir,
677 .release = cifs_closedir,
678 .read = generic_read_dir,
679 #ifdef CONFIG_CIFS_EXPERIMENTAL
680 .dir_notify = cifs_dir_notify,
681 #endif /* CONFIG_CIFS_EXPERIMENTAL */
686 cifs_init_once(void *inode, kmem_cache_t * cachep, unsigned long flags)
688 struct cifsInodeInfo *cifsi = inode;
690 if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
691 SLAB_CTOR_CONSTRUCTOR) {
692 inode_init_once(&cifsi->vfs_inode);
693 INIT_LIST_HEAD(&cifsi->lockList);
698 cifs_init_inodecache(void)
700 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
701 sizeof (struct cifsInodeInfo),
702 0, (SLAB_RECLAIM_ACCOUNT|
704 cifs_init_once, NULL);
705 if (cifs_inode_cachep == NULL)
712 cifs_destroy_inodecache(void)
714 if (kmem_cache_destroy(cifs_inode_cachep))
715 printk(KERN_WARNING "cifs_inode_cache: error freeing\n");
719 cifs_init_request_bufs(void)
721 if(CIFSMaxBufSize < 8192) {
722 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
723 Unicode path name has to fit in any SMB/CIFS path based frames */
724 CIFSMaxBufSize = 8192;
725 } else if (CIFSMaxBufSize > 1024*127) {
726 CIFSMaxBufSize = 1024 * 127;
728 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
730 /* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
731 cifs_req_cachep = kmem_cache_create("cifs_request",
733 MAX_CIFS_HDR_SIZE, 0,
734 SLAB_HWCACHE_ALIGN, NULL, NULL);
735 if (cifs_req_cachep == NULL)
740 else if (cifs_min_rcv > 64) {
742 cERROR(1,("cifs_min_rcv set to maximum (64)"));
745 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
748 if(cifs_req_poolp == NULL) {
749 kmem_cache_destroy(cifs_req_cachep);
752 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
753 almost all handle based requests (but not write response, nor is it
754 sufficient for path based requests). A smaller size would have
755 been more efficient (compacting multiple slab items on one 4k page)
756 for the case in which debug was on, but this larger size allows
757 more SMBs to use small buffer alloc and is still much more
758 efficient to alloc 1 per page off the slab compared to 17K (5page)
759 alloc of large cifs buffers even when page debugging is on */
760 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
761 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
763 if (cifs_sm_req_cachep == NULL) {
764 mempool_destroy(cifs_req_poolp);
765 kmem_cache_destroy(cifs_req_cachep);
769 if(cifs_min_small < 2)
771 else if (cifs_min_small > 256) {
772 cifs_min_small = 256;
773 cFYI(1,("cifs_min_small set to maximum (256)"));
776 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
779 if(cifs_sm_req_poolp == NULL) {
780 mempool_destroy(cifs_req_poolp);
781 kmem_cache_destroy(cifs_req_cachep);
782 kmem_cache_destroy(cifs_sm_req_cachep);
790 cifs_destroy_request_bufs(void)
792 mempool_destroy(cifs_req_poolp);
793 if (kmem_cache_destroy(cifs_req_cachep))
795 "cifs_destroy_request_cache: error not all structures were freed\n");
796 mempool_destroy(cifs_sm_req_poolp);
797 if (kmem_cache_destroy(cifs_sm_req_cachep))
799 "cifs_destroy_request_cache: cifs_small_rq free error\n");
805 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
806 sizeof (struct mid_q_entry), 0,
807 SLAB_HWCACHE_ALIGN, NULL, NULL);
808 if (cifs_mid_cachep == NULL)
811 /* 3 is a reasonable minimum number of simultaneous operations */
812 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
813 if(cifs_mid_poolp == NULL) {
814 kmem_cache_destroy(cifs_mid_cachep);
818 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
819 sizeof (struct oplock_q_entry), 0,
820 SLAB_HWCACHE_ALIGN, NULL, NULL);
821 if (cifs_oplock_cachep == NULL) {
822 kmem_cache_destroy(cifs_mid_cachep);
823 mempool_destroy(cifs_mid_poolp);
831 cifs_destroy_mids(void)
833 mempool_destroy(cifs_mid_poolp);
834 if (kmem_cache_destroy(cifs_mid_cachep))
836 "cifs_destroy_mids: error not all structures were freed\n");
838 if (kmem_cache_destroy(cifs_oplock_cachep))
840 "error not all oplock structures were freed\n");
843 static int cifs_oplock_thread(void * dummyarg)
845 struct oplock_q_entry * oplock_item;
846 struct cifsTconInfo *pTcon;
847 struct inode * inode;
855 spin_lock(&GlobalMid_Lock);
856 if(list_empty(&GlobalOplock_Q)) {
857 spin_unlock(&GlobalMid_Lock);
858 set_current_state(TASK_INTERRUPTIBLE);
859 schedule_timeout(39*HZ);
861 oplock_item = list_entry(GlobalOplock_Q.next,
862 struct oplock_q_entry, qhead);
864 cFYI(1,("found oplock item to write out"));
865 pTcon = oplock_item->tcon;
866 inode = oplock_item->pinode;
867 netfid = oplock_item->netfid;
868 spin_unlock(&GlobalMid_Lock);
869 DeleteOplockQEntry(oplock_item);
870 /* can not grab inode sem here since it would
871 deadlock when oplock received on delete
872 since vfs_unlink holds the i_mutex across
874 /* mutex_lock(&inode->i_mutex);*/
875 if (S_ISREG(inode->i_mode)) {
876 rc = filemap_fdatawrite(inode->i_mapping);
877 if(CIFS_I(inode)->clientCanCacheRead == 0) {
878 filemap_fdatawait(inode->i_mapping);
879 invalidate_remote_inode(inode);
883 /* mutex_unlock(&inode->i_mutex);*/
885 CIFS_I(inode)->write_behind_rc = rc;
886 cFYI(1,("Oplock flush inode %p rc %d",inode,rc));
888 /* releasing a stale oplock after recent reconnection
889 of smb session using a now incorrect file
890 handle is not a data integrity issue but do
891 not bother sending an oplock release if session
892 to server still is disconnected since oplock
893 already released by the server in that case */
894 if(pTcon->tidStatus != CifsNeedReconnect) {
895 rc = CIFSSMBLock(0, pTcon, netfid,
896 0 /* len */ , 0 /* offset */, 0,
897 0, LOCKING_ANDX_OPLOCK_RELEASE,
899 cFYI(1,("Oplock release rc = %d ",rc));
902 spin_unlock(&GlobalMid_Lock);
903 set_current_state(TASK_INTERRUPTIBLE);
904 schedule_timeout(1); /* yield in case q were corrupt */
906 } while (!kthread_should_stop());
911 static int cifs_dnotify_thread(void * dummyarg)
913 struct list_head *tmp;
914 struct cifsSesInfo *ses;
919 set_current_state(TASK_INTERRUPTIBLE);
920 schedule_timeout(15*HZ);
921 read_lock(&GlobalSMBSeslock);
922 /* check if any stuck requests that need
923 to be woken up and wakeq so the
924 thread can wake up and error out */
925 list_for_each(tmp, &GlobalSMBSessionList) {
926 ses = list_entry(tmp, struct cifsSesInfo,
928 if(ses && ses->server &&
929 atomic_read(&ses->server->inFlight))
930 wake_up_all(&ses->server->response_q);
932 read_unlock(&GlobalSMBSeslock);
933 } while (!kthread_should_stop());
942 #ifdef CONFIG_PROC_FS
945 /* INIT_LIST_HEAD(&GlobalServerList);*/ /* BB not implemented yet */
946 INIT_LIST_HEAD(&GlobalSMBSessionList);
947 INIT_LIST_HEAD(&GlobalTreeConnectionList);
948 INIT_LIST_HEAD(&GlobalOplock_Q);
949 #ifdef CONFIG_CIFS_EXPERIMENTAL
950 INIT_LIST_HEAD(&GlobalDnotifyReqList);
951 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
954 * Initialize Global counters
956 atomic_set(&sesInfoAllocCount, 0);
957 atomic_set(&tconInfoAllocCount, 0);
958 atomic_set(&tcpSesAllocCount,0);
959 atomic_set(&tcpSesReconnectCount, 0);
960 atomic_set(&tconInfoReconnectCount, 0);
962 atomic_set(&bufAllocCount, 0);
963 atomic_set(&smBufAllocCount, 0);
964 #ifdef CONFIG_CIFS_STATS2
965 atomic_set(&totBufAllocCount, 0);
966 atomic_set(&totSmBufAllocCount, 0);
967 #endif /* CONFIG_CIFS_STATS2 */
969 atomic_set(&midCount, 0);
970 GlobalCurrentXid = 0;
971 GlobalTotalActiveXid = 0;
972 GlobalMaxActiveXid = 0;
973 memset(Local_System_Name, 0, 15);
974 rwlock_init(&GlobalSMBSeslock);
975 spin_lock_init(&GlobalMid_Lock);
977 if(cifs_max_pending < 2) {
978 cifs_max_pending = 2;
979 cFYI(1,("cifs_max_pending set to min of 2"));
980 } else if(cifs_max_pending > 256) {
981 cifs_max_pending = 256;
982 cFYI(1,("cifs_max_pending set to max of 256"));
985 rc = cifs_init_inodecache();
989 rc = cifs_init_mids();
991 goto out_destroy_inodecache;
993 rc = cifs_init_request_bufs();
995 goto out_destroy_mids;
997 rc = register_filesystem(&cifs_fs_type);
999 goto out_destroy_request_bufs;
1001 oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
1002 if (IS_ERR(oplockThread)) {
1003 rc = PTR_ERR(oplockThread);
1004 cERROR(1,("error %d create oplock thread", rc));
1005 goto out_unregister_filesystem;
1008 dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
1009 if (IS_ERR(dnotifyThread)) {
1010 rc = PTR_ERR(dnotifyThread);
1011 cERROR(1,("error %d create dnotify thread", rc));
1012 goto out_stop_oplock_thread;
1017 out_stop_oplock_thread:
1018 kthread_stop(oplockThread);
1019 out_unregister_filesystem:
1020 unregister_filesystem(&cifs_fs_type);
1021 out_destroy_request_bufs:
1022 cifs_destroy_request_bufs();
1024 cifs_destroy_mids();
1025 out_destroy_inodecache:
1026 cifs_destroy_inodecache();
1028 #ifdef CONFIG_PROC_FS
1037 cFYI(0, ("In unregister ie exit_cifs"));
1038 #ifdef CONFIG_PROC_FS
1041 unregister_filesystem(&cifs_fs_type);
1042 cifs_destroy_inodecache();
1043 cifs_destroy_mids();
1044 cifs_destroy_request_bufs();
1045 kthread_stop(oplockThread);
1046 kthread_stop(dnotifyThread);
1049 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1050 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1052 ("VFS to access servers complying with the SNIA CIFS Specification e.g. Samba and Windows");
1053 MODULE_VERSION(CIFS_VERSION);
1054 module_init(init_cifs)
1055 module_exit(exit_cifs)