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>
38 #define DECLARE_GLOBALS_HERE
40 #include "cifsproto.h"
41 #include "cifs_debug.h"
42 #include "cifs_fs_sb.h"
44 #define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
46 #ifdef CONFIG_CIFS_QUOTA
47 static struct quotactl_ops cifs_quotactl_ops;
53 unsigned int oplockEnabled = 1;
54 unsigned int experimEnabled = 0;
55 unsigned int linuxExtEnabled = 1;
56 unsigned int lookupCacheEnabled = 1;
57 unsigned int multiuser_mount = 0;
58 unsigned int extended_security = 0;
59 unsigned int ntlmv2_support = 0;
60 unsigned int sign_CIFS_PDUs = 1;
61 extern struct task_struct * oplockThread; /* remove sparse warning */
62 struct task_struct * oplockThread = NULL;
63 extern struct task_struct * dnotifyThread; /* remove sparse warning */
64 struct task_struct * dnotifyThread = NULL;
65 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
66 module_param(CIFSMaxBufSize, int, 0);
67 MODULE_PARM_DESC(CIFSMaxBufSize,"Network buffer size (not including header). Default: 16384 Range: 8192 to 130048");
68 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
69 module_param(cifs_min_rcv, int, 0);
70 MODULE_PARM_DESC(cifs_min_rcv,"Network buffers in pool. Default: 4 Range: 1 to 64");
71 unsigned int cifs_min_small = 30;
72 module_param(cifs_min_small, int, 0);
73 MODULE_PARM_DESC(cifs_min_small,"Small network buffers in pool. Default: 30 Range: 2 to 256");
74 unsigned int cifs_max_pending = CIFS_MAX_REQ;
75 module_param(cifs_max_pending, int, 0);
76 MODULE_PARM_DESC(cifs_max_pending,"Simultaneous requests to server. Default: 50 Range: 2 to 256");
78 static DECLARE_COMPLETION(cifs_oplock_exited);
79 static DECLARE_COMPLETION(cifs_dnotify_exited);
81 extern mempool_t *cifs_sm_req_poolp;
82 extern mempool_t *cifs_req_poolp;
83 extern mempool_t *cifs_mid_poolp;
85 extern kmem_cache_t *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 sb->s_flags |= MS_NODIRATIME; /* and probably even noatime */
96 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info),GFP_KERNEL);
97 cifs_sb = CIFS_SB(sb);
101 rc = cifs_mount(sb, cifs_sb, data, devname);
106 ("cifs_mount failed w/return code = %d", rc));
107 goto out_mount_failed;
110 sb->s_magic = CIFS_MAGIC_NUMBER;
111 sb->s_op = &cifs_super_ops;
112 /* if(cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
113 sb->s_blocksize = cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
114 #ifdef CONFIG_CIFS_QUOTA
115 sb->s_qcop = &cifs_quotactl_ops;
117 sb->s_blocksize = CIFS_MAX_MSGSIZE;
118 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
119 inode = iget(sb, ROOT_I);
126 sb->s_root = d_alloc_root(inode);
136 cERROR(1, ("cifs_read_super: get root inode failed"));
142 if(cifs_sb->local_nls)
143 unload_nls(cifs_sb->local_nls);
150 cifs_put_super(struct super_block *sb)
153 struct cifs_sb_info *cifs_sb;
155 cFYI(1, ("In cifs_put_super"));
156 cifs_sb = CIFS_SB(sb);
157 if(cifs_sb == NULL) {
158 cFYI(1,("Empty cifs superblock info passed to unmount"));
161 rc = cifs_umount(sb, cifs_sb);
163 cERROR(1, ("cifs_umount failed with return code %d", rc));
165 unload_nls(cifs_sb->local_nls);
171 cifs_statfs(struct super_block *sb, struct kstatfs *buf)
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 #ifdef CONFIG_CIFS_EXPERIMENTAL
194 /* BB we could add a second check for a QFS Unix capability bit */
195 /* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */
196 if ((pTcon->ses->capabilities & CAP_UNIX) && (CIFS_POSIX_EXTENSIONS &
197 le64_to_cpu(pTcon->fsUnixInfo.Capability)))
198 rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf);
200 /* Only need to call the old QFSInfo if failed
203 #endif /* CIFS_EXPERIMENTAL */
204 rc = CIFSSMBQFSInfo(xid, pTcon, buf);
206 /* Old Windows servers do not support level 103, retry with level
207 one if old server failed the previous call */
209 rc = SMBOldQFSInfo(xid, pTcon, buf);
214 /* BB get from info in tcon struct at mount time call to QFSAttrInfo */
216 return 0; /* always return success? what if volume is no
220 static int cifs_permission(struct inode * inode, int mask, struct nameidata *nd)
222 struct cifs_sb_info *cifs_sb;
224 cifs_sb = CIFS_SB(inode->i_sb);
226 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
228 } else /* file mode might have been restricted at mount time
229 on the client (above and beyond ACL on servers) for
230 servers which do not support setting and viewing mode bits,
231 so allowing client to check permissions is useful */
232 return generic_permission(inode, mask, NULL);
235 static kmem_cache_t *cifs_inode_cachep;
236 static kmem_cache_t *cifs_req_cachep;
237 static kmem_cache_t *cifs_mid_cachep;
238 kmem_cache_t *cifs_oplock_cachep;
239 static kmem_cache_t *cifs_sm_req_cachep;
240 mempool_t *cifs_sm_req_poolp;
241 mempool_t *cifs_req_poolp;
242 mempool_t *cifs_mid_poolp;
244 static struct inode *
245 cifs_alloc_inode(struct super_block *sb)
247 struct cifsInodeInfo *cifs_inode;
248 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, SLAB_KERNEL);
251 cifs_inode->cifsAttrs = 0x20; /* default */
252 atomic_set(&cifs_inode->inUse, 0);
253 cifs_inode->time = 0;
254 /* Until the file is open and we have gotten oplock
255 info back from the server, can not assume caching of
256 file data or metadata */
257 cifs_inode->clientCanCacheRead = FALSE;
258 cifs_inode->clientCanCacheAll = FALSE;
259 cifs_inode->vfs_inode.i_blksize = CIFS_MAX_MSGSIZE;
260 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
261 cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;
262 INIT_LIST_HEAD(&cifs_inode->openFileList);
263 return &cifs_inode->vfs_inode;
267 cifs_destroy_inode(struct inode *inode)
269 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
273 * cifs_show_options() is for displaying mount options in /proc/mounts.
274 * Not all settable options are displayed but most of the important
278 cifs_show_options(struct seq_file *s, struct vfsmount *m)
280 struct cifs_sb_info *cifs_sb;
282 cifs_sb = CIFS_SB(m->mnt_sb);
286 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
287 if (cifs_sb->tcon->ses) {
288 if (cifs_sb->tcon->ses->userName)
289 seq_printf(s, ",username=%s",
290 cifs_sb->tcon->ses->userName);
291 if(cifs_sb->tcon->ses->domainName)
292 seq_printf(s, ",domain=%s",
293 cifs_sb->tcon->ses->domainName);
296 seq_printf(s, ",rsize=%d",cifs_sb->rsize);
297 seq_printf(s, ",wsize=%d",cifs_sb->wsize);
302 #ifdef CONFIG_CIFS_QUOTA
303 int cifs_xquota_set(struct super_block * sb, int quota_type, qid_t qid,
304 struct fs_disk_quota * pdquota)
308 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
309 struct cifsTconInfo *pTcon;
312 pTcon = cifs_sb->tcon;
319 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
328 int cifs_xquota_get(struct super_block * sb, int quota_type, qid_t qid,
329 struct fs_disk_quota * pdquota)
333 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
334 struct cifsTconInfo *pTcon;
337 pTcon = cifs_sb->tcon;
343 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
352 int cifs_xstate_set(struct super_block * sb, unsigned int flags, int operation)
356 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
357 struct cifsTconInfo *pTcon;
360 pTcon = cifs_sb->tcon;
366 cFYI(1,("flags: 0x%x operation: 0x%x",flags,operation));
375 int cifs_xstate_get(struct super_block * sb, struct fs_quota_stat *qstats)
379 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
380 struct cifsTconInfo *pTcon;
383 pTcon = cifs_sb->tcon;
389 cFYI(1,("pqstats %p",qstats));
398 static struct quotactl_ops cifs_quotactl_ops = {
399 .set_xquota = cifs_xquota_set,
400 .get_xquota = cifs_xquota_set,
401 .set_xstate = cifs_xstate_set,
402 .get_xstate = cifs_xstate_get,
406 #ifdef CONFIG_CIFS_EXPERIMENTAL
407 static void cifs_umount_begin(struct super_block * sblock)
409 struct cifs_sb_info *cifs_sb;
410 struct cifsTconInfo * tcon;
412 cifs_sb = CIFS_SB(sblock);
416 tcon = cifs_sb->tcon;
419 down(&tcon->tconSem);
420 if (atomic_read(&tcon->useCount) == 1)
421 tcon->tidStatus = CifsExiting;
424 /* cancel_brl_requests(tcon); */
425 /* cancel_notify_requests(tcon); */
426 if(tcon->ses && tcon->ses->server)
428 cFYI(1,("wake up tasks now - umount begin not complete"));
429 wake_up_all(&tcon->ses->server->request_q);
430 wake_up_all(&tcon->ses->server->response_q);
431 msleep(1); /* yield */
432 /* we have to kick the requests once more */
433 wake_up_all(&tcon->ses->server->response_q);
436 /* BB FIXME - finish add checks for tidStatus BB */
442 static int cifs_remount(struct super_block *sb, int *flags, char *data)
444 *flags |= MS_NODIRATIME;
448 struct super_operations cifs_super_ops = {
449 .read_inode = cifs_read_inode,
450 .put_super = cifs_put_super,
451 .statfs = cifs_statfs,
452 .alloc_inode = cifs_alloc_inode,
453 .destroy_inode = cifs_destroy_inode,
454 /* .drop_inode = generic_delete_inode,
455 .delete_inode = cifs_delete_inode, *//* Do not need the above two functions
456 unless later we add lazy close of inodes or unless the kernel forgets to call
457 us with the same number of releases (closes) as opens */
458 .show_options = cifs_show_options,
459 #ifdef CONFIG_CIFS_EXPERIMENTAL
460 .umount_begin = cifs_umount_begin,
462 .remount_fs = cifs_remount,
465 static struct super_block *
466 cifs_get_sb(struct file_system_type *fs_type,
467 int flags, const char *dev_name, void *data)
470 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
472 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
479 rc = cifs_read_super(sb, data, dev_name, flags & MS_VERBOSE ? 1 : 0);
481 up_write(&sb->s_umount);
482 deactivate_super(sb);
485 sb->s_flags |= MS_ACTIVE;
489 static ssize_t cifs_file_writev(struct file *file, const struct iovec *iov,
490 unsigned long nr_segs, loff_t *ppos)
492 struct inode *inode = file->f_dentry->d_inode;
495 written = generic_file_writev(file, iov, nr_segs, ppos);
496 if (!CIFS_I(inode)->clientCanCacheAll)
497 filemap_fdatawrite(inode->i_mapping);
501 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const char __user *buf,
502 size_t count, loff_t pos)
504 struct inode *inode = iocb->ki_filp->f_dentry->d_inode;
507 written = generic_file_aio_write(iocb, buf, count, pos);
508 if (!CIFS_I(inode)->clientCanCacheAll)
509 filemap_fdatawrite(inode->i_mapping);
513 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
515 /* origin == SEEK_END => we must revalidate the cached file length */
517 int retval = cifs_revalidate(file->f_dentry);
519 return (loff_t)retval;
521 return remote_llseek(file, offset, origin);
524 static struct file_system_type cifs_fs_type = {
525 .owner = THIS_MODULE,
527 .get_sb = cifs_get_sb,
528 .kill_sb = kill_anon_super,
531 struct inode_operations cifs_dir_inode_ops = {
532 .create = cifs_create,
533 .lookup = cifs_lookup,
534 .getattr = cifs_getattr,
535 .unlink = cifs_unlink,
536 .link = cifs_hardlink,
539 .rename = cifs_rename,
540 .permission = cifs_permission,
541 /* revalidate:cifs_revalidate, */
542 .setattr = cifs_setattr,
543 .symlink = cifs_symlink,
545 #ifdef CONFIG_CIFS_XATTR
546 .setxattr = cifs_setxattr,
547 .getxattr = cifs_getxattr,
548 .listxattr = cifs_listxattr,
549 .removexattr = cifs_removexattr,
553 struct inode_operations cifs_file_inode_ops = {
554 /* revalidate:cifs_revalidate, */
555 .setattr = cifs_setattr,
556 .getattr = cifs_getattr, /* do we need this anymore? */
557 .rename = cifs_rename,
558 .permission = cifs_permission,
559 #ifdef CONFIG_CIFS_XATTR
560 .setxattr = cifs_setxattr,
561 .getxattr = cifs_getxattr,
562 .listxattr = cifs_listxattr,
563 .removexattr = cifs_removexattr,
567 struct inode_operations cifs_symlink_inode_ops = {
568 .readlink = generic_readlink,
569 .follow_link = cifs_follow_link,
570 .put_link = cifs_put_link,
571 .permission = cifs_permission,
572 /* BB add the following two eventually */
573 /* revalidate: cifs_revalidate,
574 setattr: cifs_notify_change, *//* BB do we need notify change */
575 #ifdef CONFIG_CIFS_XATTR
576 .setxattr = cifs_setxattr,
577 .getxattr = cifs_getxattr,
578 .listxattr = cifs_listxattr,
579 .removexattr = cifs_removexattr,
583 struct file_operations cifs_file_ops = {
584 .read = do_sync_read,
585 .write = do_sync_write,
586 .readv = generic_file_readv,
587 .writev = cifs_file_writev,
588 .aio_read = generic_file_aio_read,
589 .aio_write = cifs_file_aio_write,
591 .release = cifs_close,
595 .mmap = cifs_file_mmap,
596 .sendfile = generic_file_sendfile,
597 .llseek = cifs_llseek,
598 #ifdef CONFIG_CIFS_POSIX
600 #endif /* CONFIG_CIFS_POSIX */
602 #ifdef CONFIG_CIFS_EXPERIMENTAL
603 .dir_notify = cifs_dir_notify,
604 #endif /* CONFIG_CIFS_EXPERIMENTAL */
607 struct file_operations cifs_file_direct_ops = {
608 /* no mmap, no aio, no readv -
609 BB reevaluate whether they can be done with directio, no cache */
610 .read = cifs_user_read,
611 .write = cifs_user_write,
613 .release = cifs_close,
617 .sendfile = generic_file_sendfile, /* BB removeme BB */
618 #ifdef CONFIG_CIFS_POSIX
620 #endif /* CONFIG_CIFS_POSIX */
621 .llseek = cifs_llseek,
622 #ifdef CONFIG_CIFS_EXPERIMENTAL
623 .dir_notify = cifs_dir_notify,
624 #endif /* CONFIG_CIFS_EXPERIMENTAL */
626 struct file_operations cifs_file_nobrl_ops = {
627 .read = do_sync_read,
628 .write = do_sync_write,
629 .readv = generic_file_readv,
630 .writev = cifs_file_writev,
631 .aio_read = generic_file_aio_read,
632 .aio_write = cifs_file_aio_write,
634 .release = cifs_close,
637 .mmap = cifs_file_mmap,
638 .sendfile = generic_file_sendfile,
639 .llseek = cifs_llseek,
640 #ifdef CONFIG_CIFS_POSIX
642 #endif /* CONFIG_CIFS_POSIX */
644 #ifdef CONFIG_CIFS_EXPERIMENTAL
645 .dir_notify = cifs_dir_notify,
646 #endif /* CONFIG_CIFS_EXPERIMENTAL */
649 struct file_operations cifs_file_direct_nobrl_ops = {
650 /* no mmap, no aio, no readv -
651 BB reevaluate whether they can be done with directio, no cache */
652 .read = cifs_user_read,
653 .write = cifs_user_write,
655 .release = cifs_close,
658 .sendfile = generic_file_sendfile, /* BB removeme BB */
659 #ifdef CONFIG_CIFS_POSIX
661 #endif /* CONFIG_CIFS_POSIX */
662 .llseek = cifs_llseek,
663 #ifdef CONFIG_CIFS_EXPERIMENTAL
664 .dir_notify = cifs_dir_notify,
665 #endif /* CONFIG_CIFS_EXPERIMENTAL */
668 struct file_operations cifs_dir_ops = {
669 .readdir = cifs_readdir,
670 .release = cifs_closedir,
671 .read = generic_read_dir,
672 #ifdef CONFIG_CIFS_EXPERIMENTAL
673 .dir_notify = cifs_dir_notify,
674 #endif /* CONFIG_CIFS_EXPERIMENTAL */
679 cifs_init_once(void *inode, kmem_cache_t * cachep, unsigned long flags)
681 struct cifsInodeInfo *cifsi = inode;
683 if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
684 SLAB_CTOR_CONSTRUCTOR) {
685 inode_init_once(&cifsi->vfs_inode);
686 INIT_LIST_HEAD(&cifsi->lockList);
691 cifs_init_inodecache(void)
693 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
694 sizeof (struct cifsInodeInfo),
695 0, SLAB_RECLAIM_ACCOUNT,
696 cifs_init_once, NULL);
697 if (cifs_inode_cachep == NULL)
704 cifs_destroy_inodecache(void)
706 if (kmem_cache_destroy(cifs_inode_cachep))
707 printk(KERN_WARNING "cifs_inode_cache: error freeing\n");
711 cifs_init_request_bufs(void)
713 if(CIFSMaxBufSize < 8192) {
714 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
715 Unicode path name has to fit in any SMB/CIFS path based frames */
716 CIFSMaxBufSize = 8192;
717 } else if (CIFSMaxBufSize > 1024*127) {
718 CIFSMaxBufSize = 1024 * 127;
720 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
722 /* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
723 cifs_req_cachep = kmem_cache_create("cifs_request",
725 MAX_CIFS_HDR_SIZE, 0,
726 SLAB_HWCACHE_ALIGN, NULL, NULL);
727 if (cifs_req_cachep == NULL)
732 else if (cifs_min_rcv > 64) {
734 cERROR(1,("cifs_min_rcv set to maximum (64)"));
737 cifs_req_poolp = mempool_create(cifs_min_rcv,
742 if(cifs_req_poolp == NULL) {
743 kmem_cache_destroy(cifs_req_cachep);
746 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
747 almost all handle based requests (but not write response, nor is it
748 sufficient for path based requests). A smaller size would have
749 been more efficient (compacting multiple slab items on one 4k page)
750 for the case in which debug was on, but this larger size allows
751 more SMBs to use small buffer alloc and is still much more
752 efficient to alloc 1 per page off the slab compared to 17K (5page)
753 alloc of large cifs buffers even when page debugging is on */
754 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
755 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
757 if (cifs_sm_req_cachep == NULL) {
758 mempool_destroy(cifs_req_poolp);
759 kmem_cache_destroy(cifs_req_cachep);
763 if(cifs_min_small < 2)
765 else if (cifs_min_small > 256) {
766 cifs_min_small = 256;
767 cFYI(1,("cifs_min_small set to maximum (256)"));
770 cifs_sm_req_poolp = mempool_create(cifs_min_small,
775 if(cifs_sm_req_poolp == NULL) {
776 mempool_destroy(cifs_req_poolp);
777 kmem_cache_destroy(cifs_req_cachep);
778 kmem_cache_destroy(cifs_sm_req_cachep);
786 cifs_destroy_request_bufs(void)
788 mempool_destroy(cifs_req_poolp);
789 if (kmem_cache_destroy(cifs_req_cachep))
791 "cifs_destroy_request_cache: error not all structures were freed\n");
792 mempool_destroy(cifs_sm_req_poolp);
793 if (kmem_cache_destroy(cifs_sm_req_cachep))
795 "cifs_destroy_request_cache: cifs_small_rq free error\n");
801 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
802 sizeof (struct mid_q_entry), 0,
803 SLAB_HWCACHE_ALIGN, NULL, NULL);
804 if (cifs_mid_cachep == NULL)
807 cifs_mid_poolp = mempool_create(3 /* a reasonable min simultan opers */,
811 if(cifs_mid_poolp == NULL) {
812 kmem_cache_destroy(cifs_mid_cachep);
816 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
817 sizeof (struct oplock_q_entry), 0,
818 SLAB_HWCACHE_ALIGN, NULL, NULL);
819 if (cifs_oplock_cachep == NULL) {
820 kmem_cache_destroy(cifs_mid_cachep);
821 mempool_destroy(cifs_mid_poolp);
829 cifs_destroy_mids(void)
831 mempool_destroy(cifs_mid_poolp);
832 if (kmem_cache_destroy(cifs_mid_cachep))
834 "cifs_destroy_mids: error not all structures were freed\n");
836 if (kmem_cache_destroy(cifs_oplock_cachep))
838 "error not all oplock structures were freed\n");
841 static int cifs_oplock_thread(void * dummyarg)
843 struct oplock_q_entry * oplock_item;
844 struct cifsTconInfo *pTcon;
845 struct inode * inode;
849 daemonize("cifsoplockd");
850 allow_signal(SIGTERM);
852 oplockThread = current;
857 spin_lock(&GlobalMid_Lock);
858 if(list_empty(&GlobalOplock_Q)) {
859 spin_unlock(&GlobalMid_Lock);
860 set_current_state(TASK_INTERRUPTIBLE);
861 schedule_timeout(39*HZ);
863 oplock_item = list_entry(GlobalOplock_Q.next,
864 struct oplock_q_entry, qhead);
866 cFYI(1,("found oplock item to write out"));
867 pTcon = oplock_item->tcon;
868 inode = oplock_item->pinode;
869 netfid = oplock_item->netfid;
870 spin_unlock(&GlobalMid_Lock);
871 DeleteOplockQEntry(oplock_item);
872 /* can not grab inode sem here since it would
873 deadlock when oplock received on delete
874 since vfs_unlink holds the i_mutex across
876 /* mutex_lock(&inode->i_mutex);*/
877 if (S_ISREG(inode->i_mode)) {
878 rc = filemap_fdatawrite(inode->i_mapping);
879 if(CIFS_I(inode)->clientCanCacheRead == 0) {
880 filemap_fdatawait(inode->i_mapping);
881 invalidate_remote_inode(inode);
885 /* mutex_unlock(&inode->i_mutex);*/
887 CIFS_I(inode)->write_behind_rc = rc;
888 cFYI(1,("Oplock flush inode %p rc %d",inode,rc));
890 /* releasing a stale oplock after recent reconnection
891 of smb session using a now incorrect file
892 handle is not a data integrity issue but do
893 not bother sending an oplock release if session
894 to server still is disconnected since oplock
895 already released by the server in that case */
896 if(pTcon->tidStatus != CifsNeedReconnect) {
897 rc = CIFSSMBLock(0, pTcon, netfid,
898 0 /* len */ , 0 /* offset */, 0,
899 0, LOCKING_ANDX_OPLOCK_RELEASE,
901 cFYI(1,("Oplock release rc = %d ",rc));
904 spin_unlock(&GlobalMid_Lock);
905 set_current_state(TASK_INTERRUPTIBLE);
906 schedule_timeout(1); /* yield in case q were corrupt */
908 } while(!signal_pending(current));
910 complete_and_exit (&cifs_oplock_exited, 0);
913 static int cifs_dnotify_thread(void * dummyarg)
915 struct list_head *tmp;
916 struct cifsSesInfo *ses;
918 daemonize("cifsdnotifyd");
919 allow_signal(SIGTERM);
921 dnotifyThread = current;
925 set_current_state(TASK_INTERRUPTIBLE);
926 schedule_timeout(15*HZ);
927 read_lock(&GlobalSMBSeslock);
928 /* check if any stuck requests that need
929 to be woken up and wakeq so the
930 thread can wake up and error out */
931 list_for_each(tmp, &GlobalSMBSessionList) {
932 ses = list_entry(tmp, struct cifsSesInfo,
934 if(ses && ses->server &&
935 atomic_read(&ses->server->inFlight))
936 wake_up_all(&ses->server->response_q);
938 read_unlock(&GlobalSMBSeslock);
939 } while(!signal_pending(current));
940 complete_and_exit (&cifs_dnotify_exited, 0);
947 #ifdef CONFIG_PROC_FS
950 INIT_LIST_HEAD(&GlobalServerList); /* BB not implemented yet */
951 INIT_LIST_HEAD(&GlobalSMBSessionList);
952 INIT_LIST_HEAD(&GlobalTreeConnectionList);
953 INIT_LIST_HEAD(&GlobalOplock_Q);
954 #ifdef CONFIG_CIFS_EXPERIMENTAL
955 INIT_LIST_HEAD(&GlobalDnotifyReqList);
956 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
959 * Initialize Global counters
961 atomic_set(&sesInfoAllocCount, 0);
962 atomic_set(&tconInfoAllocCount, 0);
963 atomic_set(&tcpSesAllocCount,0);
964 atomic_set(&tcpSesReconnectCount, 0);
965 atomic_set(&tconInfoReconnectCount, 0);
967 atomic_set(&bufAllocCount, 0);
968 atomic_set(&smBufAllocCount, 0);
969 #ifdef CONFIG_CIFS_STATS2
970 atomic_set(&totBufAllocCount, 0);
971 atomic_set(&totSmBufAllocCount, 0);
972 #endif /* CONFIG_CIFS_STATS2 */
974 atomic_set(&midCount, 0);
975 GlobalCurrentXid = 0;
976 GlobalTotalActiveXid = 0;
977 GlobalMaxActiveXid = 0;
978 rwlock_init(&GlobalSMBSeslock);
979 spin_lock_init(&GlobalMid_Lock);
981 if(cifs_max_pending < 2) {
982 cifs_max_pending = 2;
983 cFYI(1,("cifs_max_pending set to min of 2"));
984 } else if(cifs_max_pending > 256) {
985 cifs_max_pending = 256;
986 cFYI(1,("cifs_max_pending set to max of 256"));
989 rc = cifs_init_inodecache();
991 rc = cifs_init_mids();
993 rc = cifs_init_request_bufs();
995 rc = register_filesystem(&cifs_fs_type);
997 rc = (int)kernel_thread(cifs_oplock_thread, NULL,
998 CLONE_FS | CLONE_FILES | CLONE_VM);
1000 rc = (int)kernel_thread(cifs_dnotify_thread, NULL,
1001 CLONE_FS | CLONE_FILES | CLONE_VM);
1005 cERROR(1,("error %d create dnotify thread", rc));
1007 cERROR(1,("error %d create oplock thread",rc));
1010 cifs_destroy_request_bufs();
1012 cifs_destroy_mids();
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();
1034 send_sig(SIGTERM, oplockThread, 1);
1035 wait_for_completion(&cifs_oplock_exited);
1038 send_sig(SIGTERM, dnotifyThread, 1);
1039 wait_for_completion(&cifs_dnotify_exited);
1043 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1044 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1046 ("VFS to access servers complying with the SNIA CIFS Specification e.g. Samba and Windows");
1047 MODULE_VERSION(CIFS_VERSION);
1048 module_init(init_cifs)
1049 module_exit(exit_cifs)