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>
37 #define DECLARE_GLOBALS_HERE
39 #include "cifsproto.h"
40 #include "cifs_debug.h"
41 #include "cifs_fs_sb.h"
43 #define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
45 #ifdef CONFIG_CIFS_QUOTA
46 static struct quotactl_ops cifs_quotactl_ops;
52 unsigned int oplockEnabled = 1;
53 unsigned int experimEnabled = 0;
54 unsigned int linuxExtEnabled = 1;
55 unsigned int lookupCacheEnabled = 1;
56 unsigned int multiuser_mount = 0;
57 unsigned int extended_security = 0;
58 unsigned int ntlmv2_support = 0;
59 unsigned int sign_CIFS_PDUs = 1;
60 extern struct task_struct * oplockThread; /* remove sparse warning */
61 struct task_struct * oplockThread = NULL;
62 extern struct task_struct * dnotifyThread; /* remove sparse warning */
63 struct task_struct * dnotifyThread = NULL;
64 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
65 module_param(CIFSMaxBufSize, int, 0);
66 MODULE_PARM_DESC(CIFSMaxBufSize,"Network buffer size (not including header). Default: 16384 Range: 8192 to 130048");
67 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
68 module_param(cifs_min_rcv, int, 0);
69 MODULE_PARM_DESC(cifs_min_rcv,"Network buffers in pool. Default: 4 Range: 1 to 64");
70 unsigned int cifs_min_small = 30;
71 module_param(cifs_min_small, int, 0);
72 MODULE_PARM_DESC(cifs_min_small,"Small network buffers in pool. Default: 30 Range: 2 to 256");
73 unsigned int cifs_max_pending = CIFS_MAX_REQ;
74 module_param(cifs_max_pending, int, 0);
75 MODULE_PARM_DESC(cifs_max_pending,"Simultaneous requests to server. Default: 50 Range: 2 to 256");
77 static DECLARE_COMPLETION(cifs_oplock_exited);
78 static DECLARE_COMPLETION(cifs_dnotify_exited);
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 = kmalloc(sizeof(struct cifs_sb_info),GFP_KERNEL);
96 cifs_sb = CIFS_SB(sb);
100 memset(cifs_sb,0,sizeof(struct cifs_sb_info));
103 rc = cifs_mount(sb, cifs_sb, data, devname);
108 ("cifs_mount failed w/return code = %d", rc));
109 goto out_mount_failed;
112 sb->s_magic = CIFS_MAGIC_NUMBER;
113 sb->s_op = &cifs_super_ops;
114 /* if(cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
115 sb->s_blocksize = cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
116 #ifdef CONFIG_CIFS_QUOTA
117 sb->s_qcop = &cifs_quotactl_ops;
119 sb->s_blocksize = CIFS_MAX_MSGSIZE;
120 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
121 inode = iget(sb, ROOT_I);
128 sb->s_root = d_alloc_root(inode);
138 cERROR(1, ("cifs_read_super: get root inode failed"));
144 if(cifs_sb->local_nls)
145 unload_nls(cifs_sb->local_nls);
152 cifs_put_super(struct super_block *sb)
155 struct cifs_sb_info *cifs_sb;
157 cFYI(1, ("In cifs_put_super"));
158 cifs_sb = CIFS_SB(sb);
159 if(cifs_sb == NULL) {
160 cFYI(1,("Empty cifs superblock info passed to unmount"));
163 rc = cifs_umount(sb, cifs_sb);
165 cERROR(1, ("cifs_umount failed with return code %d", rc));
167 unload_nls(cifs_sb->local_nls);
173 cifs_statfs(struct super_block *sb, struct kstatfs *buf)
176 int rc = -EOPNOTSUPP;
177 struct cifs_sb_info *cifs_sb;
178 struct cifsTconInfo *pTcon;
182 cifs_sb = CIFS_SB(sb);
183 pTcon = cifs_sb->tcon;
185 buf->f_type = CIFS_MAGIC_NUMBER;
187 /* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */
188 buf->f_namelen = PATH_MAX; /* PATH_MAX may be too long - it would
189 presumably be total path, but note
190 that some servers (includinng Samba 3)
191 have a shorter maximum path */
192 buf->f_files = 0; /* undefined */
193 buf->f_ffree = 0; /* unlimited */
195 #ifdef CONFIG_CIFS_EXPERIMENTAL
196 /* BB we could add a second check for a QFS Unix capability bit */
197 /* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */
198 if ((pTcon->ses->capabilities & CAP_UNIX) && (CIFS_POSIX_EXTENSIONS &
199 le64_to_cpu(pTcon->fsUnixInfo.Capability)))
200 rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf);
202 /* Only need to call the old QFSInfo if failed
205 #endif /* CIFS_EXPERIMENTAL */
206 rc = CIFSSMBQFSInfo(xid, pTcon, buf);
208 /* Old Windows servers do not support level 103, retry with level
209 one if old server failed the previous call */
211 rc = SMBOldQFSInfo(xid, pTcon, buf);
216 /* BB get from info in tcon struct at mount time call to QFSAttrInfo */
218 return 0; /* always return success? what if volume is no
222 static int cifs_permission(struct inode * inode, int mask, struct nameidata *nd)
224 struct cifs_sb_info *cifs_sb;
226 cifs_sb = CIFS_SB(inode->i_sb);
228 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
230 } else /* file mode might have been restricted at mount time
231 on the client (above and beyond ACL on servers) for
232 servers which do not support setting and viewing mode bits,
233 so allowing client to check permissions is useful */
234 return generic_permission(inode, mask, NULL);
237 static kmem_cache_t *cifs_inode_cachep;
238 static kmem_cache_t *cifs_req_cachep;
239 static kmem_cache_t *cifs_mid_cachep;
240 kmem_cache_t *cifs_oplock_cachep;
241 static kmem_cache_t *cifs_sm_req_cachep;
242 mempool_t *cifs_sm_req_poolp;
243 mempool_t *cifs_req_poolp;
244 mempool_t *cifs_mid_poolp;
246 static struct inode *
247 cifs_alloc_inode(struct super_block *sb)
249 struct cifsInodeInfo *cifs_inode;
250 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, SLAB_KERNEL);
253 cifs_inode->cifsAttrs = 0x20; /* default */
254 atomic_set(&cifs_inode->inUse, 0);
255 cifs_inode->time = 0;
256 /* Until the file is open and we have gotten oplock
257 info back from the server, can not assume caching of
258 file data or metadata */
259 cifs_inode->clientCanCacheRead = FALSE;
260 cifs_inode->clientCanCacheAll = FALSE;
261 cifs_inode->vfs_inode.i_blksize = CIFS_MAX_MSGSIZE;
262 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
263 cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;
264 INIT_LIST_HEAD(&cifs_inode->openFileList);
265 return &cifs_inode->vfs_inode;
269 cifs_destroy_inode(struct inode *inode)
271 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
275 * cifs_show_options() is for displaying mount options in /proc/mounts.
276 * Not all settable options are displayed but most of the important
280 cifs_show_options(struct seq_file *s, struct vfsmount *m)
282 struct cifs_sb_info *cifs_sb;
284 cifs_sb = CIFS_SB(m->mnt_sb);
288 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
289 if (cifs_sb->tcon->ses) {
290 if (cifs_sb->tcon->ses->userName)
291 seq_printf(s, ",username=%s",
292 cifs_sb->tcon->ses->userName);
293 if(cifs_sb->tcon->ses->domainName)
294 seq_printf(s, ",domain=%s",
295 cifs_sb->tcon->ses->domainName);
298 seq_printf(s, ",rsize=%d",cifs_sb->rsize);
299 seq_printf(s, ",wsize=%d",cifs_sb->wsize);
304 #ifdef CONFIG_CIFS_QUOTA
305 int cifs_xquota_set(struct super_block * sb, int quota_type, qid_t qid,
306 struct fs_disk_quota * pdquota)
310 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
311 struct cifsTconInfo *pTcon;
314 pTcon = cifs_sb->tcon;
321 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
330 int cifs_xquota_get(struct super_block * sb, int quota_type, qid_t qid,
331 struct fs_disk_quota * pdquota)
335 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
336 struct cifsTconInfo *pTcon;
339 pTcon = cifs_sb->tcon;
345 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
354 int cifs_xstate_set(struct super_block * sb, unsigned int flags, int operation)
358 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
359 struct cifsTconInfo *pTcon;
362 pTcon = cifs_sb->tcon;
368 cFYI(1,("flags: 0x%x operation: 0x%x",flags,operation));
377 int cifs_xstate_get(struct super_block * sb, struct fs_quota_stat *qstats)
381 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
382 struct cifsTconInfo *pTcon;
385 pTcon = cifs_sb->tcon;
391 cFYI(1,("pqstats %p",qstats));
400 static struct quotactl_ops cifs_quotactl_ops = {
401 .set_xquota = cifs_xquota_set,
402 .get_xquota = cifs_xquota_set,
403 .set_xstate = cifs_xstate_set,
404 .get_xstate = cifs_xstate_get,
408 static void cifs_umount_begin(struct super_block * sblock)
410 struct cifs_sb_info *cifs_sb;
412 cifs_sb = CIFS_SB(sb);
415 if(cifs_sb->tcon == NULL)
417 down(&tcon->tconSem);
418 if (atomic_read(&tcon->useCount) == 1)
419 tcon->tidStatus = CifsExiting;
422 if((cifs->sb->tcon->ses) && (cifs_sb->tcon->ses->server))
424 cERROR(1,("wake up tasks now - umount begin not complete"));
425 wake_up_all(&server->request_q);
427 /* BB FIXME - finish add checks for tidStatus BB */
433 static int cifs_remount(struct super_block *sb, int *flags, char *data)
435 *flags |= MS_NODIRATIME;
439 struct super_operations cifs_super_ops = {
440 .read_inode = cifs_read_inode,
441 .put_super = cifs_put_super,
442 .statfs = cifs_statfs,
443 .alloc_inode = cifs_alloc_inode,
444 .destroy_inode = cifs_destroy_inode,
445 /* .drop_inode = generic_delete_inode,
446 .delete_inode = cifs_delete_inode, *//* Do not need the above two functions
447 unless later we add lazy close of inodes or unless the kernel forgets to call
448 us with the same number of releases (closes) as opens */
449 .show_options = cifs_show_options,
450 /* .umount_begin = cifs_umount_begin, */ /* BB finish in the future */
451 .remount_fs = cifs_remount,
454 static struct super_block *
455 cifs_get_sb(struct file_system_type *fs_type,
456 int flags, const char *dev_name, void *data)
459 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
461 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
468 rc = cifs_read_super(sb, data, dev_name, flags & MS_VERBOSE ? 1 : 0);
470 up_write(&sb->s_umount);
471 deactivate_super(sb);
474 sb->s_flags |= MS_ACTIVE;
479 cifs_read_wrapper(struct file * file, char __user *read_data, size_t read_size,
482 if(file->f_dentry == NULL)
484 else if(file->f_dentry->d_inode == NULL)
487 cFYI(1,("In read_wrapper size %zd at %lld",read_size,*poffset));
489 if(CIFS_I(file->f_dentry->d_inode)->clientCanCacheRead) {
490 return generic_file_read(file,read_data,read_size,poffset);
492 /* BB do we need to lock inode from here until after invalidate? */
493 /* if(file->f_dentry->d_inode->i_mapping) {
494 filemap_fdatawrite(file->f_dentry->d_inode->i_mapping);
495 filemap_fdatawait(file->f_dentry->d_inode->i_mapping);
497 /* cifs_revalidate(file->f_dentry);*/ /* BB fixme */
499 /* BB we should make timer configurable - perhaps
500 by simply calling cifs_revalidate here */
501 /* invalidate_remote_inode(file->f_dentry->d_inode);*/
502 return generic_file_read(file,read_data,read_size,poffset);
507 cifs_write_wrapper(struct file * file, const char __user *write_data,
508 size_t write_size, loff_t * poffset)
512 if(file->f_dentry == NULL)
514 else if(file->f_dentry->d_inode == NULL)
517 cFYI(1,("In write_wrapper size %zd at %lld",write_size,*poffset));
519 written = generic_file_write(file,write_data,write_size,poffset);
520 if(!CIFS_I(file->f_dentry->d_inode)->clientCanCacheAll) {
521 if(file->f_dentry->d_inode->i_mapping) {
522 filemap_fdatawrite(file->f_dentry->d_inode->i_mapping);
529 static struct file_system_type cifs_fs_type = {
530 .owner = THIS_MODULE,
532 .get_sb = cifs_get_sb,
533 .kill_sb = kill_anon_super,
536 struct inode_operations cifs_dir_inode_ops = {
537 .create = cifs_create,
538 .lookup = cifs_lookup,
539 .getattr = cifs_getattr,
540 .unlink = cifs_unlink,
541 .link = cifs_hardlink,
544 .rename = cifs_rename,
545 .permission = cifs_permission,
546 /* revalidate:cifs_revalidate, */
547 .setattr = cifs_setattr,
548 .symlink = cifs_symlink,
550 #ifdef CONFIG_CIFS_XATTR
551 .setxattr = cifs_setxattr,
552 .getxattr = cifs_getxattr,
553 .listxattr = cifs_listxattr,
554 .removexattr = cifs_removexattr,
558 struct inode_operations cifs_file_inode_ops = {
559 /* revalidate:cifs_revalidate, */
560 .setattr = cifs_setattr,
561 .getattr = cifs_getattr, /* do we need this anymore? */
562 .rename = cifs_rename,
563 .permission = cifs_permission,
564 #ifdef CONFIG_CIFS_XATTR
565 .setxattr = cifs_setxattr,
566 .getxattr = cifs_getxattr,
567 .listxattr = cifs_listxattr,
568 .removexattr = cifs_removexattr,
572 struct inode_operations cifs_symlink_inode_ops = {
573 .readlink = generic_readlink,
574 .follow_link = cifs_follow_link,
575 .put_link = cifs_put_link,
576 .permission = cifs_permission,
577 /* BB add the following two eventually */
578 /* revalidate: cifs_revalidate,
579 setattr: cifs_notify_change, *//* BB do we need notify change */
580 #ifdef CONFIG_CIFS_XATTR
581 .setxattr = cifs_setxattr,
582 .getxattr = cifs_getxattr,
583 .listxattr = cifs_listxattr,
584 .removexattr = cifs_removexattr,
588 struct file_operations cifs_file_ops = {
589 .read = cifs_read_wrapper,
590 .write = cifs_write_wrapper,
592 .release = cifs_close,
596 .mmap = cifs_file_mmap,
597 .sendfile = generic_file_sendfile,
598 #ifdef CONFIG_CIFS_POSIX
600 #endif /* CONFIG_CIFS_POSIX */
602 #ifdef CONFIG_CIFS_EXPERIMENTAL
603 .readv = generic_file_readv,
604 .writev = generic_file_writev,
605 .aio_read = generic_file_aio_read,
606 .aio_write = generic_file_aio_write,
607 .dir_notify = cifs_dir_notify,
608 #endif /* CONFIG_CIFS_EXPERIMENTAL */
611 struct file_operations cifs_file_direct_ops = {
612 /* no mmap, no aio, no readv -
613 BB reevaluate whether they can be done with directio, no cache */
614 .read = cifs_user_read,
615 .write = cifs_user_write,
617 .release = cifs_close,
621 .sendfile = generic_file_sendfile, /* BB removeme BB */
622 #ifdef CONFIG_CIFS_POSIX
624 #endif /* CONFIG_CIFS_POSIX */
626 #ifdef CONFIG_CIFS_EXPERIMENTAL
627 .dir_notify = cifs_dir_notify,
628 #endif /* CONFIG_CIFS_EXPERIMENTAL */
631 struct file_operations cifs_dir_ops = {
632 .readdir = cifs_readdir,
633 .release = cifs_closedir,
634 .read = generic_read_dir,
635 #ifdef CONFIG_CIFS_EXPERIMENTAL
636 .dir_notify = cifs_dir_notify,
637 #endif /* CONFIG_CIFS_EXPERIMENTAL */
642 cifs_init_once(void *inode, kmem_cache_t * cachep, unsigned long flags)
644 struct cifsInodeInfo *cifsi = inode;
646 if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
647 SLAB_CTOR_CONSTRUCTOR) {
648 inode_init_once(&cifsi->vfs_inode);
649 INIT_LIST_HEAD(&cifsi->lockList);
654 cifs_init_inodecache(void)
656 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
657 sizeof (struct cifsInodeInfo),
658 0, SLAB_RECLAIM_ACCOUNT,
659 cifs_init_once, NULL);
660 if (cifs_inode_cachep == NULL)
667 cifs_destroy_inodecache(void)
669 if (kmem_cache_destroy(cifs_inode_cachep))
670 printk(KERN_WARNING "cifs_inode_cache: error freeing\n");
674 cifs_init_request_bufs(void)
676 if(CIFSMaxBufSize < 8192) {
677 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
678 Unicode path name has to fit in any SMB/CIFS path based frames */
679 CIFSMaxBufSize = 8192;
680 } else if (CIFSMaxBufSize > 1024*127) {
681 CIFSMaxBufSize = 1024 * 127;
683 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
685 /* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
686 cifs_req_cachep = kmem_cache_create("cifs_request",
688 MAX_CIFS_HDR_SIZE, 0,
689 SLAB_HWCACHE_ALIGN, NULL, NULL);
690 if (cifs_req_cachep == NULL)
695 else if (cifs_min_rcv > 64) {
697 cERROR(1,("cifs_min_rcv set to maximum (64)"));
700 cifs_req_poolp = mempool_create(cifs_min_rcv,
705 if(cifs_req_poolp == NULL) {
706 kmem_cache_destroy(cifs_req_cachep);
709 /* 256 (MAX_CIFS_HDR_SIZE bytes is enough for most SMB responses and
710 almost all handle based requests (but not write response, nor is it
711 sufficient for path based requests). A smaller size would have
712 been more efficient (compacting multiple slab items on one 4k page)
713 for the case in which debug was on, but this larger size allows
714 more SMBs to use small buffer alloc and is still much more
715 efficient to alloc 1 per page off the slab compared to 17K (5page)
716 alloc of large cifs buffers even when page debugging is on */
717 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
718 MAX_CIFS_HDR_SIZE, 0, SLAB_HWCACHE_ALIGN, NULL, NULL);
719 if (cifs_sm_req_cachep == NULL) {
720 mempool_destroy(cifs_req_poolp);
721 kmem_cache_destroy(cifs_req_cachep);
725 if(cifs_min_small < 2)
727 else if (cifs_min_small > 256) {
728 cifs_min_small = 256;
729 cFYI(1,("cifs_min_small set to maximum (256)"));
732 cifs_sm_req_poolp = mempool_create(cifs_min_small,
737 if(cifs_sm_req_poolp == NULL) {
738 mempool_destroy(cifs_req_poolp);
739 kmem_cache_destroy(cifs_req_cachep);
740 kmem_cache_destroy(cifs_sm_req_cachep);
748 cifs_destroy_request_bufs(void)
750 mempool_destroy(cifs_req_poolp);
751 if (kmem_cache_destroy(cifs_req_cachep))
753 "cifs_destroy_request_cache: error not all structures were freed\n");
754 mempool_destroy(cifs_sm_req_poolp);
755 if (kmem_cache_destroy(cifs_sm_req_cachep))
757 "cifs_destroy_request_cache: cifs_small_rq free error\n");
763 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
764 sizeof (struct mid_q_entry), 0,
765 SLAB_HWCACHE_ALIGN, NULL, NULL);
766 if (cifs_mid_cachep == NULL)
769 cifs_mid_poolp = mempool_create(3 /* a reasonable min simultan opers */,
773 if(cifs_mid_poolp == NULL) {
774 kmem_cache_destroy(cifs_mid_cachep);
778 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
779 sizeof (struct oplock_q_entry), 0,
780 SLAB_HWCACHE_ALIGN, NULL, NULL);
781 if (cifs_oplock_cachep == NULL) {
782 kmem_cache_destroy(cifs_mid_cachep);
783 mempool_destroy(cifs_mid_poolp);
791 cifs_destroy_mids(void)
793 mempool_destroy(cifs_mid_poolp);
794 if (kmem_cache_destroy(cifs_mid_cachep))
796 "cifs_destroy_mids: error not all structures were freed\n");
798 if (kmem_cache_destroy(cifs_oplock_cachep))
800 "error not all oplock structures were freed\n");
803 static int cifs_oplock_thread(void * dummyarg)
805 struct oplock_q_entry * oplock_item;
806 struct cifsTconInfo *pTcon;
807 struct inode * inode;
811 daemonize("cifsoplockd");
812 allow_signal(SIGTERM);
814 oplockThread = current;
819 spin_lock(&GlobalMid_Lock);
820 if(list_empty(&GlobalOplock_Q)) {
821 spin_unlock(&GlobalMid_Lock);
822 set_current_state(TASK_INTERRUPTIBLE);
823 schedule_timeout(39*HZ);
825 oplock_item = list_entry(GlobalOplock_Q.next,
826 struct oplock_q_entry, qhead);
828 cFYI(1,("found oplock item to write out"));
829 pTcon = oplock_item->tcon;
830 inode = oplock_item->pinode;
831 netfid = oplock_item->netfid;
832 spin_unlock(&GlobalMid_Lock);
833 DeleteOplockQEntry(oplock_item);
834 /* can not grab inode sem here since it would
835 deadlock when oplock received on delete
836 since vfs_unlink holds the i_sem across
838 /* down(&inode->i_sem);*/
839 if (S_ISREG(inode->i_mode)) {
840 rc = filemap_fdatawrite(inode->i_mapping);
841 if(CIFS_I(inode)->clientCanCacheRead == 0) {
842 filemap_fdatawait(inode->i_mapping);
843 invalidate_remote_inode(inode);
847 /* up(&inode->i_sem);*/
849 CIFS_I(inode)->write_behind_rc = rc;
850 cFYI(1,("Oplock flush inode %p rc %d",inode,rc));
852 /* releasing a stale oplock after recent reconnection
853 of smb session using a now incorrect file
854 handle is not a data integrity issue but do
855 not bother sending an oplock release if session
856 to server still is disconnected since oplock
857 already released by the server in that case */
858 if(pTcon->tidStatus != CifsNeedReconnect) {
859 rc = CIFSSMBLock(0, pTcon, netfid,
860 0 /* len */ , 0 /* offset */, 0,
861 0, LOCKING_ANDX_OPLOCK_RELEASE,
863 cFYI(1,("Oplock release rc = %d ",rc));
866 spin_unlock(&GlobalMid_Lock);
867 set_current_state(TASK_INTERRUPTIBLE);
868 schedule_timeout(1); /* yield in case q were corrupt */
870 } while(!signal_pending(current));
872 complete_and_exit (&cifs_oplock_exited, 0);
875 static int cifs_dnotify_thread(void * dummyarg)
877 daemonize("cifsdnotifyd");
878 allow_signal(SIGTERM);
880 dnotifyThread = current;
884 set_current_state(TASK_INTERRUPTIBLE);
885 schedule_timeout(39*HZ);
886 } while(!signal_pending(current));
887 complete_and_exit (&cifs_dnotify_exited, 0);
894 #ifdef CONFIG_PROC_FS
897 INIT_LIST_HEAD(&GlobalServerList); /* BB not implemented yet */
898 INIT_LIST_HEAD(&GlobalSMBSessionList);
899 INIT_LIST_HEAD(&GlobalTreeConnectionList);
900 INIT_LIST_HEAD(&GlobalOplock_Q);
902 * Initialize Global counters
904 atomic_set(&sesInfoAllocCount, 0);
905 atomic_set(&tconInfoAllocCount, 0);
906 atomic_set(&tcpSesAllocCount,0);
907 atomic_set(&tcpSesReconnectCount, 0);
908 atomic_set(&tconInfoReconnectCount, 0);
910 atomic_set(&bufAllocCount, 0);
911 atomic_set(&midCount, 0);
912 GlobalCurrentXid = 0;
913 GlobalTotalActiveXid = 0;
914 GlobalMaxActiveXid = 0;
915 rwlock_init(&GlobalSMBSeslock);
916 spin_lock_init(&GlobalMid_Lock);
918 if(cifs_max_pending < 2) {
919 cifs_max_pending = 2;
920 cFYI(1,("cifs_max_pending set to min of 2"));
921 } else if(cifs_max_pending > 256) {
922 cifs_max_pending = 256;
923 cFYI(1,("cifs_max_pending set to max of 256"));
926 rc = cifs_init_inodecache();
928 rc = cifs_init_mids();
930 rc = cifs_init_request_bufs();
932 rc = register_filesystem(&cifs_fs_type);
934 rc = (int)kernel_thread(cifs_oplock_thread, NULL,
935 CLONE_FS | CLONE_FILES | CLONE_VM);
937 rc = (int)kernel_thread(cifs_dnotify_thread, NULL,
938 CLONE_FS | CLONE_FILES | CLONE_VM);
942 cERROR(1,("error %d create dnotify thread", rc));
944 cERROR(1,("error %d create oplock thread",rc));
947 cifs_destroy_request_bufs();
951 cifs_destroy_inodecache();
953 #ifdef CONFIG_PROC_FS
962 cFYI(0, ("In unregister ie exit_cifs"));
963 #ifdef CONFIG_PROC_FS
966 unregister_filesystem(&cifs_fs_type);
967 cifs_destroy_inodecache();
969 cifs_destroy_request_bufs();
971 send_sig(SIGTERM, oplockThread, 1);
972 wait_for_completion(&cifs_oplock_exited);
975 send_sig(SIGTERM, dnotifyThread, 1);
976 wait_for_completion(&cifs_dnotify_exited);
980 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
981 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
983 ("VFS to access servers complying with the SNIA CIFS Specification e.g. Samba and Windows");
984 MODULE_VERSION(CIFS_VERSION);
985 module_init(init_cifs)
986 module_exit(exit_cifs)