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 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
67 module_param(CIFSMaxBufSize, int, 0);
68 MODULE_PARM_DESC(CIFSMaxBufSize,"Network buffer size (not including header). Default: 16384 Range: 8192 to 130048");
69 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
70 module_param(cifs_min_rcv, int, 0);
71 MODULE_PARM_DESC(cifs_min_rcv,"Network buffers in pool. Default: 4 Range: 1 to 64");
72 unsigned int cifs_min_small = 30;
73 module_param(cifs_min_small, int, 0);
74 MODULE_PARM_DESC(cifs_min_small,"Small network buffers in pool. Default: 30 Range: 2 to 256");
75 unsigned int cifs_max_pending = CIFS_MAX_REQ;
76 module_param(cifs_max_pending, int, 0);
77 MODULE_PARM_DESC(cifs_max_pending,"Simultaneous requests to server. Default: 50 Range: 2 to 256");
79 extern mempool_t *cifs_sm_req_poolp;
80 extern mempool_t *cifs_req_poolp;
81 extern mempool_t *cifs_mid_poolp;
83 extern kmem_cache_t *cifs_oplock_cachep;
86 cifs_read_super(struct super_block *sb, void *data,
87 const char *devname, int silent)
90 struct cifs_sb_info *cifs_sb;
93 sb->s_flags |= MS_NODIRATIME; /* and probably even noatime */
94 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info),GFP_KERNEL);
95 cifs_sb = CIFS_SB(sb);
99 rc = cifs_mount(sb, cifs_sb, data, devname);
104 ("cifs_mount failed w/return code = %d", rc));
105 goto out_mount_failed;
108 sb->s_magic = CIFS_MAGIC_NUMBER;
109 sb->s_op = &cifs_super_ops;
110 /* if(cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
111 sb->s_blocksize = cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
112 #ifdef CONFIG_CIFS_QUOTA
113 sb->s_qcop = &cifs_quotactl_ops;
115 sb->s_blocksize = CIFS_MAX_MSGSIZE;
116 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
117 inode = iget(sb, ROOT_I);
124 sb->s_root = d_alloc_root(inode);
134 cERROR(1, ("cifs_read_super: get root inode failed"));
140 if(cifs_sb->local_nls)
141 unload_nls(cifs_sb->local_nls);
148 cifs_put_super(struct super_block *sb)
151 struct cifs_sb_info *cifs_sb;
153 cFYI(1, ("In cifs_put_super"));
154 cifs_sb = CIFS_SB(sb);
155 if(cifs_sb == NULL) {
156 cFYI(1,("Empty cifs superblock info passed to unmount"));
159 rc = cifs_umount(sb, cifs_sb);
161 cERROR(1, ("cifs_umount failed with return code %d", rc));
163 unload_nls(cifs_sb->local_nls);
169 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
171 struct super_block *sb = dentry->d_sb;
173 int rc = -EOPNOTSUPP;
174 struct cifs_sb_info *cifs_sb;
175 struct cifsTconInfo *pTcon;
179 cifs_sb = CIFS_SB(sb);
180 pTcon = cifs_sb->tcon;
182 buf->f_type = CIFS_MAGIC_NUMBER;
184 /* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */
185 buf->f_namelen = PATH_MAX; /* PATH_MAX may be too long - it would
186 presumably be total path, but note
187 that some servers (includinng Samba 3)
188 have a shorter maximum path */
189 buf->f_files = 0; /* undefined */
190 buf->f_ffree = 0; /* unlimited */
192 #ifdef CONFIG_CIFS_EXPERIMENTAL
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 #endif /* CIFS_EXPERIMENTAL */
203 rc = CIFSSMBQFSInfo(xid, pTcon, buf);
205 /* Old Windows servers do not support level 103, retry with level
206 one if old server failed the previous call */
208 rc = SMBOldQFSInfo(xid, pTcon, buf);
213 /* BB get from info in tcon struct at mount time call to QFSAttrInfo */
215 return 0; /* always return success? what if volume is no
219 static int cifs_permission(struct inode * inode, int mask, struct nameidata *nd)
221 struct cifs_sb_info *cifs_sb;
223 cifs_sb = CIFS_SB(inode->i_sb);
225 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
227 } else /* file mode might have been restricted at mount time
228 on the client (above and beyond ACL on servers) for
229 servers which do not support setting and viewing mode bits,
230 so allowing client to check permissions is useful */
231 return generic_permission(inode, mask, NULL);
234 static kmem_cache_t *cifs_inode_cachep;
235 static kmem_cache_t *cifs_req_cachep;
236 static kmem_cache_t *cifs_mid_cachep;
237 kmem_cache_t *cifs_oplock_cachep;
238 static kmem_cache_t *cifs_sm_req_cachep;
239 mempool_t *cifs_sm_req_poolp;
240 mempool_t *cifs_req_poolp;
241 mempool_t *cifs_mid_poolp;
243 static struct inode *
244 cifs_alloc_inode(struct super_block *sb)
246 struct cifsInodeInfo *cifs_inode;
247 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, SLAB_KERNEL);
250 cifs_inode->cifsAttrs = 0x20; /* default */
251 atomic_set(&cifs_inode->inUse, 0);
252 cifs_inode->time = 0;
253 /* Until the file is open and we have gotten oplock
254 info back from the server, can not assume caching of
255 file data or metadata */
256 cifs_inode->clientCanCacheRead = FALSE;
257 cifs_inode->clientCanCacheAll = FALSE;
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 static int cifs_remount(struct super_block *sb, int *flags, char *data)
442 *flags |= MS_NODIRATIME;
446 struct super_operations cifs_super_ops = {
447 .read_inode = cifs_read_inode,
448 .put_super = cifs_put_super,
449 .statfs = cifs_statfs,
450 .alloc_inode = cifs_alloc_inode,
451 .destroy_inode = cifs_destroy_inode,
452 /* .drop_inode = generic_delete_inode,
453 .delete_inode = cifs_delete_inode, *//* Do not need the above two functions
454 unless later we add lazy close of inodes or unless the kernel forgets to call
455 us with the same number of releases (closes) as opens */
456 .show_options = cifs_show_options,
457 .umount_begin = cifs_umount_begin,
458 .remount_fs = cifs_remount,
462 cifs_get_sb(struct file_system_type *fs_type,
463 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
466 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
468 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
475 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
477 up_write(&sb->s_umount);
478 deactivate_super(sb);
481 sb->s_flags |= MS_ACTIVE;
482 return simple_set_mnt(mnt, sb);
485 static ssize_t cifs_file_writev(struct file *file, const struct iovec *iov,
486 unsigned long nr_segs, loff_t *ppos)
488 struct inode *inode = file->f_dentry->d_inode;
491 written = generic_file_writev(file, iov, nr_segs, ppos);
492 if (!CIFS_I(inode)->clientCanCacheAll)
493 filemap_fdatawrite(inode->i_mapping);
497 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const char __user *buf,
498 size_t count, loff_t pos)
500 struct inode *inode = iocb->ki_filp->f_dentry->d_inode;
503 written = generic_file_aio_write(iocb, buf, count, pos);
504 if (!CIFS_I(inode)->clientCanCacheAll)
505 filemap_fdatawrite(inode->i_mapping);
509 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
511 /* origin == SEEK_END => we must revalidate the cached file length */
513 int retval = cifs_revalidate(file->f_dentry);
515 return (loff_t)retval;
517 return remote_llseek(file, offset, origin);
520 static struct file_system_type cifs_fs_type = {
521 .owner = THIS_MODULE,
523 .get_sb = cifs_get_sb,
524 .kill_sb = kill_anon_super,
527 struct inode_operations cifs_dir_inode_ops = {
528 .create = cifs_create,
529 .lookup = cifs_lookup,
530 .getattr = cifs_getattr,
531 .unlink = cifs_unlink,
532 .link = cifs_hardlink,
535 .rename = cifs_rename,
536 .permission = cifs_permission,
537 /* revalidate:cifs_revalidate, */
538 .setattr = cifs_setattr,
539 .symlink = cifs_symlink,
541 #ifdef CONFIG_CIFS_XATTR
542 .setxattr = cifs_setxattr,
543 .getxattr = cifs_getxattr,
544 .listxattr = cifs_listxattr,
545 .removexattr = cifs_removexattr,
549 struct inode_operations cifs_file_inode_ops = {
550 /* revalidate:cifs_revalidate, */
551 .setattr = cifs_setattr,
552 .getattr = cifs_getattr, /* do we need this anymore? */
553 .rename = cifs_rename,
554 .permission = cifs_permission,
555 #ifdef CONFIG_CIFS_XATTR
556 .setxattr = cifs_setxattr,
557 .getxattr = cifs_getxattr,
558 .listxattr = cifs_listxattr,
559 .removexattr = cifs_removexattr,
563 struct inode_operations cifs_symlink_inode_ops = {
564 .readlink = generic_readlink,
565 .follow_link = cifs_follow_link,
566 .put_link = cifs_put_link,
567 .permission = cifs_permission,
568 /* BB add the following two eventually */
569 /* revalidate: cifs_revalidate,
570 setattr: cifs_notify_change, *//* BB do we need notify change */
571 #ifdef CONFIG_CIFS_XATTR
572 .setxattr = cifs_setxattr,
573 .getxattr = cifs_getxattr,
574 .listxattr = cifs_listxattr,
575 .removexattr = cifs_removexattr,
579 const struct file_operations cifs_file_ops = {
580 .read = do_sync_read,
581 .write = do_sync_write,
582 .readv = generic_file_readv,
583 .writev = cifs_file_writev,
584 .aio_read = generic_file_aio_read,
585 .aio_write = cifs_file_aio_write,
587 .release = cifs_close,
591 .mmap = cifs_file_mmap,
592 .sendfile = generic_file_sendfile,
593 .llseek = cifs_llseek,
594 #ifdef CONFIG_CIFS_POSIX
596 #endif /* CONFIG_CIFS_POSIX */
598 #ifdef CONFIG_CIFS_EXPERIMENTAL
599 .dir_notify = cifs_dir_notify,
600 #endif /* CONFIG_CIFS_EXPERIMENTAL */
603 const struct file_operations cifs_file_direct_ops = {
604 /* no mmap, no aio, no readv -
605 BB reevaluate whether they can be done with directio, no cache */
606 .read = cifs_user_read,
607 .write = cifs_user_write,
609 .release = cifs_close,
613 .sendfile = generic_file_sendfile, /* BB removeme BB */
614 #ifdef CONFIG_CIFS_POSIX
616 #endif /* CONFIG_CIFS_POSIX */
617 .llseek = cifs_llseek,
618 #ifdef CONFIG_CIFS_EXPERIMENTAL
619 .dir_notify = cifs_dir_notify,
620 #endif /* CONFIG_CIFS_EXPERIMENTAL */
622 const struct file_operations cifs_file_nobrl_ops = {
623 .read = do_sync_read,
624 .write = do_sync_write,
625 .readv = generic_file_readv,
626 .writev = cifs_file_writev,
627 .aio_read = generic_file_aio_read,
628 .aio_write = cifs_file_aio_write,
630 .release = cifs_close,
633 .mmap = cifs_file_mmap,
634 .sendfile = generic_file_sendfile,
635 .llseek = cifs_llseek,
636 #ifdef CONFIG_CIFS_POSIX
638 #endif /* CONFIG_CIFS_POSIX */
640 #ifdef CONFIG_CIFS_EXPERIMENTAL
641 .dir_notify = cifs_dir_notify,
642 #endif /* CONFIG_CIFS_EXPERIMENTAL */
645 const struct file_operations cifs_file_direct_nobrl_ops = {
646 /* no mmap, no aio, no readv -
647 BB reevaluate whether they can be done with directio, no cache */
648 .read = cifs_user_read,
649 .write = cifs_user_write,
651 .release = cifs_close,
654 .sendfile = generic_file_sendfile, /* BB removeme BB */
655 #ifdef CONFIG_CIFS_POSIX
657 #endif /* CONFIG_CIFS_POSIX */
658 .llseek = cifs_llseek,
659 #ifdef CONFIG_CIFS_EXPERIMENTAL
660 .dir_notify = cifs_dir_notify,
661 #endif /* CONFIG_CIFS_EXPERIMENTAL */
664 const struct file_operations cifs_dir_ops = {
665 .readdir = cifs_readdir,
666 .release = cifs_closedir,
667 .read = generic_read_dir,
668 #ifdef CONFIG_CIFS_EXPERIMENTAL
669 .dir_notify = cifs_dir_notify,
670 #endif /* CONFIG_CIFS_EXPERIMENTAL */
675 cifs_init_once(void *inode, kmem_cache_t * cachep, unsigned long flags)
677 struct cifsInodeInfo *cifsi = inode;
679 if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
680 SLAB_CTOR_CONSTRUCTOR) {
681 inode_init_once(&cifsi->vfs_inode);
682 INIT_LIST_HEAD(&cifsi->lockList);
687 cifs_init_inodecache(void)
689 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
690 sizeof (struct cifsInodeInfo),
691 0, (SLAB_RECLAIM_ACCOUNT|
693 cifs_init_once, NULL);
694 if (cifs_inode_cachep == NULL)
701 cifs_destroy_inodecache(void)
703 if (kmem_cache_destroy(cifs_inode_cachep))
704 printk(KERN_WARNING "cifs_inode_cache: error freeing\n");
708 cifs_init_request_bufs(void)
710 if(CIFSMaxBufSize < 8192) {
711 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
712 Unicode path name has to fit in any SMB/CIFS path based frames */
713 CIFSMaxBufSize = 8192;
714 } else if (CIFSMaxBufSize > 1024*127) {
715 CIFSMaxBufSize = 1024 * 127;
717 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
719 /* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
720 cifs_req_cachep = kmem_cache_create("cifs_request",
722 MAX_CIFS_HDR_SIZE, 0,
723 SLAB_HWCACHE_ALIGN, NULL, NULL);
724 if (cifs_req_cachep == NULL)
729 else if (cifs_min_rcv > 64) {
731 cERROR(1,("cifs_min_rcv set to maximum (64)"));
734 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
737 if(cifs_req_poolp == NULL) {
738 kmem_cache_destroy(cifs_req_cachep);
741 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
742 almost all handle based requests (but not write response, nor is it
743 sufficient for path based requests). A smaller size would have
744 been more efficient (compacting multiple slab items on one 4k page)
745 for the case in which debug was on, but this larger size allows
746 more SMBs to use small buffer alloc and is still much more
747 efficient to alloc 1 per page off the slab compared to 17K (5page)
748 alloc of large cifs buffers even when page debugging is on */
749 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
750 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
752 if (cifs_sm_req_cachep == NULL) {
753 mempool_destroy(cifs_req_poolp);
754 kmem_cache_destroy(cifs_req_cachep);
758 if(cifs_min_small < 2)
760 else if (cifs_min_small > 256) {
761 cifs_min_small = 256;
762 cFYI(1,("cifs_min_small set to maximum (256)"));
765 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
768 if(cifs_sm_req_poolp == NULL) {
769 mempool_destroy(cifs_req_poolp);
770 kmem_cache_destroy(cifs_req_cachep);
771 kmem_cache_destroy(cifs_sm_req_cachep);
779 cifs_destroy_request_bufs(void)
781 mempool_destroy(cifs_req_poolp);
782 if (kmem_cache_destroy(cifs_req_cachep))
784 "cifs_destroy_request_cache: error not all structures were freed\n");
785 mempool_destroy(cifs_sm_req_poolp);
786 if (kmem_cache_destroy(cifs_sm_req_cachep))
788 "cifs_destroy_request_cache: cifs_small_rq free error\n");
794 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
795 sizeof (struct mid_q_entry), 0,
796 SLAB_HWCACHE_ALIGN, NULL, NULL);
797 if (cifs_mid_cachep == NULL)
800 /* 3 is a reasonable minimum number of simultaneous operations */
801 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
802 if(cifs_mid_poolp == NULL) {
803 kmem_cache_destroy(cifs_mid_cachep);
807 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
808 sizeof (struct oplock_q_entry), 0,
809 SLAB_HWCACHE_ALIGN, NULL, NULL);
810 if (cifs_oplock_cachep == NULL) {
811 kmem_cache_destroy(cifs_mid_cachep);
812 mempool_destroy(cifs_mid_poolp);
820 cifs_destroy_mids(void)
822 mempool_destroy(cifs_mid_poolp);
823 if (kmem_cache_destroy(cifs_mid_cachep))
825 "cifs_destroy_mids: error not all structures were freed\n");
827 if (kmem_cache_destroy(cifs_oplock_cachep))
829 "error not all oplock structures were freed\n");
832 static int cifs_oplock_thread(void * dummyarg)
834 struct oplock_q_entry * oplock_item;
835 struct cifsTconInfo *pTcon;
836 struct inode * inode;
844 spin_lock(&GlobalMid_Lock);
845 if(list_empty(&GlobalOplock_Q)) {
846 spin_unlock(&GlobalMid_Lock);
847 set_current_state(TASK_INTERRUPTIBLE);
848 schedule_timeout(39*HZ);
850 oplock_item = list_entry(GlobalOplock_Q.next,
851 struct oplock_q_entry, qhead);
853 cFYI(1,("found oplock item to write out"));
854 pTcon = oplock_item->tcon;
855 inode = oplock_item->pinode;
856 netfid = oplock_item->netfid;
857 spin_unlock(&GlobalMid_Lock);
858 DeleteOplockQEntry(oplock_item);
859 /* can not grab inode sem here since it would
860 deadlock when oplock received on delete
861 since vfs_unlink holds the i_mutex across
863 /* mutex_lock(&inode->i_mutex);*/
864 if (S_ISREG(inode->i_mode)) {
865 rc = filemap_fdatawrite(inode->i_mapping);
866 if(CIFS_I(inode)->clientCanCacheRead == 0) {
867 filemap_fdatawait(inode->i_mapping);
868 invalidate_remote_inode(inode);
872 /* mutex_unlock(&inode->i_mutex);*/
874 CIFS_I(inode)->write_behind_rc = rc;
875 cFYI(1,("Oplock flush inode %p rc %d",inode,rc));
877 /* releasing a stale oplock after recent reconnection
878 of smb session using a now incorrect file
879 handle is not a data integrity issue but do
880 not bother sending an oplock release if session
881 to server still is disconnected since oplock
882 already released by the server in that case */
883 if(pTcon->tidStatus != CifsNeedReconnect) {
884 rc = CIFSSMBLock(0, pTcon, netfid,
885 0 /* len */ , 0 /* offset */, 0,
886 0, LOCKING_ANDX_OPLOCK_RELEASE,
888 cFYI(1,("Oplock release rc = %d ",rc));
891 spin_unlock(&GlobalMid_Lock);
892 set_current_state(TASK_INTERRUPTIBLE);
893 schedule_timeout(1); /* yield in case q were corrupt */
895 } while (!kthread_should_stop());
900 static int cifs_dnotify_thread(void * dummyarg)
902 struct list_head *tmp;
903 struct cifsSesInfo *ses;
908 set_current_state(TASK_INTERRUPTIBLE);
909 schedule_timeout(15*HZ);
910 read_lock(&GlobalSMBSeslock);
911 /* check if any stuck requests that need
912 to be woken up and wakeq so the
913 thread can wake up and error out */
914 list_for_each(tmp, &GlobalSMBSessionList) {
915 ses = list_entry(tmp, struct cifsSesInfo,
917 if(ses && ses->server &&
918 atomic_read(&ses->server->inFlight))
919 wake_up_all(&ses->server->response_q);
921 read_unlock(&GlobalSMBSeslock);
922 } while (!kthread_should_stop());
931 #ifdef CONFIG_PROC_FS
934 INIT_LIST_HEAD(&GlobalServerList); /* BB not implemented yet */
935 INIT_LIST_HEAD(&GlobalSMBSessionList);
936 INIT_LIST_HEAD(&GlobalTreeConnectionList);
937 INIT_LIST_HEAD(&GlobalOplock_Q);
938 #ifdef CONFIG_CIFS_EXPERIMENTAL
939 INIT_LIST_HEAD(&GlobalDnotifyReqList);
940 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
943 * Initialize Global counters
945 atomic_set(&sesInfoAllocCount, 0);
946 atomic_set(&tconInfoAllocCount, 0);
947 atomic_set(&tcpSesAllocCount,0);
948 atomic_set(&tcpSesReconnectCount, 0);
949 atomic_set(&tconInfoReconnectCount, 0);
951 atomic_set(&bufAllocCount, 0);
952 atomic_set(&smBufAllocCount, 0);
953 #ifdef CONFIG_CIFS_STATS2
954 atomic_set(&totBufAllocCount, 0);
955 atomic_set(&totSmBufAllocCount, 0);
956 #endif /* CONFIG_CIFS_STATS2 */
958 atomic_set(&midCount, 0);
959 GlobalCurrentXid = 0;
960 GlobalTotalActiveXid = 0;
961 GlobalMaxActiveXid = 0;
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)