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 static int cifs_remount(struct super_block *sb, int *flags, char *data)
442 *flags |= MS_NODIRATIME;
446 static 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 */
512 if (origin == SEEK_END) {
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 memset(Local_System_Name, 0, 15);
963 rwlock_init(&GlobalSMBSeslock);
964 spin_lock_init(&GlobalMid_Lock);
966 if(cifs_max_pending < 2) {
967 cifs_max_pending = 2;
968 cFYI(1,("cifs_max_pending set to min of 2"));
969 } else if(cifs_max_pending > 256) {
970 cifs_max_pending = 256;
971 cFYI(1,("cifs_max_pending set to max of 256"));
974 rc = cifs_init_inodecache();
978 rc = cifs_init_mids();
980 goto out_destroy_inodecache;
982 rc = cifs_init_request_bufs();
984 goto out_destroy_mids;
986 rc = register_filesystem(&cifs_fs_type);
988 goto out_destroy_request_bufs;
990 oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
991 if (IS_ERR(oplockThread)) {
992 rc = PTR_ERR(oplockThread);
993 cERROR(1,("error %d create oplock thread", rc));
994 goto out_unregister_filesystem;
997 dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
998 if (IS_ERR(dnotifyThread)) {
999 rc = PTR_ERR(dnotifyThread);
1000 cERROR(1,("error %d create dnotify thread", rc));
1001 goto out_stop_oplock_thread;
1006 out_stop_oplock_thread:
1007 kthread_stop(oplockThread);
1008 out_unregister_filesystem:
1009 unregister_filesystem(&cifs_fs_type);
1010 out_destroy_request_bufs:
1011 cifs_destroy_request_bufs();
1013 cifs_destroy_mids();
1014 out_destroy_inodecache:
1015 cifs_destroy_inodecache();
1017 #ifdef CONFIG_PROC_FS
1026 cFYI(0, ("In unregister ie exit_cifs"));
1027 #ifdef CONFIG_PROC_FS
1030 unregister_filesystem(&cifs_fs_type);
1031 cifs_destroy_inodecache();
1032 cifs_destroy_mids();
1033 cifs_destroy_request_bufs();
1034 kthread_stop(oplockThread);
1035 kthread_stop(dnotifyThread);
1038 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1039 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1041 ("VFS to access servers complying with the SNIA CIFS Specification e.g. Samba and Windows");
1042 MODULE_VERSION(CIFS_VERSION);
1043 module_init(init_cifs)
1044 module_exit(exit_cifs)