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 cERROR(1,("kill all tasks now - umount begin not implemented yet"));
412 /* BB FIXME - finish BB */
418 static int cifs_remount(struct super_block *sb, int *flags, char *data)
420 *flags |= MS_NODIRATIME;
424 struct super_operations cifs_super_ops = {
425 .read_inode = cifs_read_inode,
426 .put_super = cifs_put_super,
427 .statfs = cifs_statfs,
428 .alloc_inode = cifs_alloc_inode,
429 .destroy_inode = cifs_destroy_inode,
430 /* .drop_inode = generic_delete_inode,
431 .delete_inode = cifs_delete_inode, *//* Do not need the above two functions
432 unless later we add lazy close of inodes or unless the kernel forgets to call
433 us with the same number of releases (closes) as opens */
434 .show_options = cifs_show_options,
435 /* .umount_begin = cifs_umount_begin, */ /* BB finish in the future */
436 .remount_fs = cifs_remount,
439 static struct super_block *
440 cifs_get_sb(struct file_system_type *fs_type,
441 int flags, const char *dev_name, void *data)
444 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
446 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
453 rc = cifs_read_super(sb, data, dev_name, flags & MS_VERBOSE ? 1 : 0);
455 up_write(&sb->s_umount);
456 deactivate_super(sb);
459 sb->s_flags |= MS_ACTIVE;
464 cifs_read_wrapper(struct file * file, char __user *read_data, size_t read_size,
467 if(file->f_dentry == NULL)
469 else if(file->f_dentry->d_inode == NULL)
472 cFYI(1,("In read_wrapper size %zd at %lld",read_size,*poffset));
474 if(CIFS_I(file->f_dentry->d_inode)->clientCanCacheRead) {
475 return generic_file_read(file,read_data,read_size,poffset);
477 /* BB do we need to lock inode from here until after invalidate? */
478 /* if(file->f_dentry->d_inode->i_mapping) {
479 filemap_fdatawrite(file->f_dentry->d_inode->i_mapping);
480 filemap_fdatawait(file->f_dentry->d_inode->i_mapping);
482 /* cifs_revalidate(file->f_dentry);*/ /* BB fixme */
484 /* BB we should make timer configurable - perhaps
485 by simply calling cifs_revalidate here */
486 /* invalidate_remote_inode(file->f_dentry->d_inode);*/
487 return generic_file_read(file,read_data,read_size,poffset);
492 cifs_write_wrapper(struct file * file, const char __user *write_data,
493 size_t write_size, loff_t * poffset)
497 if(file->f_dentry == NULL)
499 else if(file->f_dentry->d_inode == NULL)
502 cFYI(1,("In write_wrapper size %zd at %lld",write_size,*poffset));
504 written = generic_file_write(file,write_data,write_size,poffset);
505 if(!CIFS_I(file->f_dentry->d_inode)->clientCanCacheAll) {
506 if(file->f_dentry->d_inode->i_mapping) {
507 filemap_fdatawrite(file->f_dentry->d_inode->i_mapping);
514 static struct file_system_type cifs_fs_type = {
515 .owner = THIS_MODULE,
517 .get_sb = cifs_get_sb,
518 .kill_sb = kill_anon_super,
521 struct inode_operations cifs_dir_inode_ops = {
522 .create = cifs_create,
523 .lookup = cifs_lookup,
524 .getattr = cifs_getattr,
525 .unlink = cifs_unlink,
526 .link = cifs_hardlink,
529 .rename = cifs_rename,
530 .permission = cifs_permission,
531 /* revalidate:cifs_revalidate, */
532 .setattr = cifs_setattr,
533 .symlink = cifs_symlink,
535 #ifdef CONFIG_CIFS_XATTR
536 .setxattr = cifs_setxattr,
537 .getxattr = cifs_getxattr,
538 .listxattr = cifs_listxattr,
539 .removexattr = cifs_removexattr,
543 struct inode_operations cifs_file_inode_ops = {
544 /* revalidate:cifs_revalidate, */
545 .setattr = cifs_setattr,
546 .getattr = cifs_getattr, /* do we need this anymore? */
547 .rename = cifs_rename,
548 .permission = cifs_permission,
549 #ifdef CONFIG_CIFS_XATTR
550 .setxattr = cifs_setxattr,
551 .getxattr = cifs_getxattr,
552 .listxattr = cifs_listxattr,
553 .removexattr = cifs_removexattr,
557 struct inode_operations cifs_symlink_inode_ops = {
558 .readlink = generic_readlink,
559 .follow_link = cifs_follow_link,
560 .put_link = cifs_put_link,
561 .permission = cifs_permission,
562 /* BB add the following two eventually */
563 /* revalidate: cifs_revalidate,
564 setattr: cifs_notify_change, *//* BB do we need notify change */
565 #ifdef CONFIG_CIFS_XATTR
566 .setxattr = cifs_setxattr,
567 .getxattr = cifs_getxattr,
568 .listxattr = cifs_listxattr,
569 .removexattr = cifs_removexattr,
573 struct file_operations cifs_file_ops = {
574 .read = cifs_read_wrapper,
575 .write = cifs_write_wrapper,
577 .release = cifs_close,
581 .mmap = cifs_file_mmap,
582 .sendfile = generic_file_sendfile,
583 #ifdef CONFIG_CIFS_POSIX
585 #endif /* CONFIG_CIFS_POSIX */
587 #ifdef CONFIG_CIFS_EXPERIMENTAL
588 .readv = generic_file_readv,
589 .writev = generic_file_writev,
590 .aio_read = generic_file_aio_read,
591 .aio_write = generic_file_aio_write,
592 .dir_notify = cifs_dir_notify,
593 #endif /* CONFIG_CIFS_EXPERIMENTAL */
596 struct file_operations cifs_file_direct_ops = {
597 /* no mmap, no aio, no readv -
598 BB reevaluate whether they can be done with directio, no cache */
599 .read = cifs_user_read,
600 .write = cifs_user_write,
602 .release = cifs_close,
606 .sendfile = generic_file_sendfile, /* BB removeme BB */
607 #ifdef CONFIG_CIFS_POSIX
609 #endif /* CONFIG_CIFS_POSIX */
611 #ifdef CONFIG_CIFS_EXPERIMENTAL
612 .dir_notify = cifs_dir_notify,
613 #endif /* CONFIG_CIFS_EXPERIMENTAL */
616 struct file_operations cifs_dir_ops = {
617 .readdir = cifs_readdir,
618 .release = cifs_closedir,
619 .read = generic_read_dir,
620 #ifdef CONFIG_CIFS_EXPERIMENTAL
621 .dir_notify = cifs_dir_notify,
622 #endif /* CONFIG_CIFS_EXPERIMENTAL */
627 cifs_init_once(void *inode, kmem_cache_t * cachep, unsigned long flags)
629 struct cifsInodeInfo *cifsi = inode;
631 if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
632 SLAB_CTOR_CONSTRUCTOR) {
633 inode_init_once(&cifsi->vfs_inode);
634 INIT_LIST_HEAD(&cifsi->lockList);
639 cifs_init_inodecache(void)
641 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
642 sizeof (struct cifsInodeInfo),
643 0, SLAB_RECLAIM_ACCOUNT,
644 cifs_init_once, NULL);
645 if (cifs_inode_cachep == NULL)
652 cifs_destroy_inodecache(void)
654 if (kmem_cache_destroy(cifs_inode_cachep))
655 printk(KERN_WARNING "cifs_inode_cache: error freeing\n");
659 cifs_init_request_bufs(void)
661 if(CIFSMaxBufSize < 8192) {
662 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
663 Unicode path name has to fit in any SMB/CIFS path based frames */
664 CIFSMaxBufSize = 8192;
665 } else if (CIFSMaxBufSize > 1024*127) {
666 CIFSMaxBufSize = 1024 * 127;
668 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
670 /* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
671 cifs_req_cachep = kmem_cache_create("cifs_request",
673 MAX_CIFS_HDR_SIZE, 0,
674 SLAB_HWCACHE_ALIGN, NULL, NULL);
675 if (cifs_req_cachep == NULL)
680 else if (cifs_min_rcv > 64) {
682 cERROR(1,("cifs_min_rcv set to maximum (64)"));
685 cifs_req_poolp = mempool_create(cifs_min_rcv,
690 if(cifs_req_poolp == NULL) {
691 kmem_cache_destroy(cifs_req_cachep);
694 /* 256 (MAX_CIFS_HDR_SIZE bytes is enough for most SMB responses and
695 almost all handle based requests (but not write response, nor is it
696 sufficient for path based requests). A smaller size would have
697 been more efficient (compacting multiple slab items on one 4k page)
698 for the case in which debug was on, but this larger size allows
699 more SMBs to use small buffer alloc and is still much more
700 efficient to alloc 1 per page off the slab compared to 17K (5page)
701 alloc of large cifs buffers even when page debugging is on */
702 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
703 MAX_CIFS_HDR_SIZE, 0, SLAB_HWCACHE_ALIGN, NULL, NULL);
704 if (cifs_sm_req_cachep == NULL) {
705 mempool_destroy(cifs_req_poolp);
706 kmem_cache_destroy(cifs_req_cachep);
710 if(cifs_min_small < 2)
712 else if (cifs_min_small > 256) {
713 cifs_min_small = 256;
714 cFYI(1,("cifs_min_small set to maximum (256)"));
717 cifs_sm_req_poolp = mempool_create(cifs_min_small,
722 if(cifs_sm_req_poolp == NULL) {
723 mempool_destroy(cifs_req_poolp);
724 kmem_cache_destroy(cifs_req_cachep);
725 kmem_cache_destroy(cifs_sm_req_cachep);
733 cifs_destroy_request_bufs(void)
735 mempool_destroy(cifs_req_poolp);
736 if (kmem_cache_destroy(cifs_req_cachep))
738 "cifs_destroy_request_cache: error not all structures were freed\n");
739 mempool_destroy(cifs_sm_req_poolp);
740 if (kmem_cache_destroy(cifs_sm_req_cachep))
742 "cifs_destroy_request_cache: cifs_small_rq free error\n");
748 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
749 sizeof (struct mid_q_entry), 0,
750 SLAB_HWCACHE_ALIGN, NULL, NULL);
751 if (cifs_mid_cachep == NULL)
754 cifs_mid_poolp = mempool_create(3 /* a reasonable min simultan opers */,
758 if(cifs_mid_poolp == NULL) {
759 kmem_cache_destroy(cifs_mid_cachep);
763 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
764 sizeof (struct oplock_q_entry), 0,
765 SLAB_HWCACHE_ALIGN, NULL, NULL);
766 if (cifs_oplock_cachep == NULL) {
767 kmem_cache_destroy(cifs_mid_cachep);
768 mempool_destroy(cifs_mid_poolp);
776 cifs_destroy_mids(void)
778 mempool_destroy(cifs_mid_poolp);
779 if (kmem_cache_destroy(cifs_mid_cachep))
781 "cifs_destroy_mids: error not all structures were freed\n");
783 if (kmem_cache_destroy(cifs_oplock_cachep))
785 "error not all oplock structures were freed\n");
788 static int cifs_oplock_thread(void * dummyarg)
790 struct oplock_q_entry * oplock_item;
791 struct cifsTconInfo *pTcon;
792 struct inode * inode;
796 daemonize("cifsoplockd");
797 allow_signal(SIGTERM);
799 oplockThread = current;
804 spin_lock(&GlobalMid_Lock);
805 if(list_empty(&GlobalOplock_Q)) {
806 spin_unlock(&GlobalMid_Lock);
807 set_current_state(TASK_INTERRUPTIBLE);
808 schedule_timeout(39*HZ);
810 oplock_item = list_entry(GlobalOplock_Q.next,
811 struct oplock_q_entry, qhead);
813 cFYI(1,("found oplock item to write out"));
814 pTcon = oplock_item->tcon;
815 inode = oplock_item->pinode;
816 netfid = oplock_item->netfid;
817 spin_unlock(&GlobalMid_Lock);
818 DeleteOplockQEntry(oplock_item);
819 /* can not grab inode sem here since it would
820 deadlock when oplock received on delete
821 since vfs_unlink holds the i_sem across
823 /* down(&inode->i_sem);*/
824 if (S_ISREG(inode->i_mode)) {
825 rc = filemap_fdatawrite(inode->i_mapping);
826 if(CIFS_I(inode)->clientCanCacheRead == 0) {
827 filemap_fdatawait(inode->i_mapping);
828 invalidate_remote_inode(inode);
832 /* up(&inode->i_sem);*/
834 CIFS_I(inode)->write_behind_rc = rc;
835 cFYI(1,("Oplock flush inode %p rc %d",inode,rc));
837 /* releasing a stale oplock after recent reconnection
838 of smb session using a now incorrect file
839 handle is not a data integrity issue but do
840 not bother sending an oplock release if session
841 to server still is disconnected since oplock
842 already released by the server in that case */
843 if(pTcon->tidStatus != CifsNeedReconnect) {
844 rc = CIFSSMBLock(0, pTcon, netfid,
845 0 /* len */ , 0 /* offset */, 0,
846 0, LOCKING_ANDX_OPLOCK_RELEASE,
848 cFYI(1,("Oplock release rc = %d ",rc));
851 spin_unlock(&GlobalMid_Lock);
852 set_current_state(TASK_INTERRUPTIBLE);
853 schedule_timeout(1); /* yield in case q were corrupt */
855 } while(!signal_pending(current));
857 complete_and_exit (&cifs_oplock_exited, 0);
860 static int cifs_dnotify_thread(void * dummyarg)
862 daemonize("cifsdnotifyd");
863 allow_signal(SIGTERM);
865 dnotifyThread = current;
869 set_current_state(TASK_INTERRUPTIBLE);
870 schedule_timeout(39*HZ);
871 } while(!signal_pending(current));
872 complete_and_exit (&cifs_dnotify_exited, 0);
879 #ifdef CONFIG_PROC_FS
882 INIT_LIST_HEAD(&GlobalServerList); /* BB not implemented yet */
883 INIT_LIST_HEAD(&GlobalSMBSessionList);
884 INIT_LIST_HEAD(&GlobalTreeConnectionList);
885 INIT_LIST_HEAD(&GlobalOplock_Q);
887 * Initialize Global counters
889 atomic_set(&sesInfoAllocCount, 0);
890 atomic_set(&tconInfoAllocCount, 0);
891 atomic_set(&tcpSesAllocCount,0);
892 atomic_set(&tcpSesReconnectCount, 0);
893 atomic_set(&tconInfoReconnectCount, 0);
895 atomic_set(&bufAllocCount, 0);
896 atomic_set(&midCount, 0);
897 GlobalCurrentXid = 0;
898 GlobalTotalActiveXid = 0;
899 GlobalMaxActiveXid = 0;
900 rwlock_init(&GlobalSMBSeslock);
901 spin_lock_init(&GlobalMid_Lock);
903 if(cifs_max_pending < 2) {
904 cifs_max_pending = 2;
905 cFYI(1,("cifs_max_pending set to min of 2"));
906 } else if(cifs_max_pending > 256) {
907 cifs_max_pending = 256;
908 cFYI(1,("cifs_max_pending set to max of 256"));
911 rc = cifs_init_inodecache();
913 rc = cifs_init_mids();
915 rc = cifs_init_request_bufs();
917 rc = register_filesystem(&cifs_fs_type);
919 rc = (int)kernel_thread(cifs_oplock_thread, NULL,
920 CLONE_FS | CLONE_FILES | CLONE_VM);
922 rc = (int)kernel_thread(cifs_dnotify_thread, NULL,
923 CLONE_FS | CLONE_FILES | CLONE_VM);
927 cERROR(1,("error %d create dnotify thread", rc));
929 cERROR(1,("error %d create oplock thread",rc));
932 cifs_destroy_request_bufs();
936 cifs_destroy_inodecache();
938 #ifdef CONFIG_PROC_FS
947 cFYI(0, ("In unregister ie exit_cifs"));
948 #ifdef CONFIG_PROC_FS
951 unregister_filesystem(&cifs_fs_type);
952 cifs_destroy_inodecache();
954 cifs_destroy_request_bufs();
956 send_sig(SIGTERM, oplockThread, 1);
957 wait_for_completion(&cifs_oplock_exited);
960 send_sig(SIGTERM, dnotifyThread, 1);
961 wait_for_completion(&cifs_dnotify_exited);
965 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
966 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
968 ("VFS to access servers complying with the SNIA CIFS Specification e.g. Samba and Windows");
969 MODULE_VERSION(CIFS_VERSION);
970 module_init(init_cifs)
971 module_exit(exit_cifs)