4 * Copyright (C) International Business Machines Corp., 2002,2007
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>
37 #include <linux/freezer.h>
40 #define DECLARE_GLOBALS_HERE
42 #include "cifsproto.h"
43 #include "cifs_debug.h"
44 #include "cifs_fs_sb.h"
46 #include <linux/key-type.h>
47 #include "dns_resolve.h"
48 #include "cifs_spnego.h"
49 #define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
51 #ifdef CONFIG_CIFS_QUOTA
52 static struct quotactl_ops cifs_quotactl_ops;
58 unsigned int oplockEnabled = 1;
59 unsigned int experimEnabled = 0;
60 unsigned int linuxExtEnabled = 1;
61 unsigned int lookupCacheEnabled = 1;
62 unsigned int multiuser_mount = 0;
63 unsigned int extended_security = CIFSSEC_DEF;
64 /* unsigned int ntlmv2_support = 0; */
65 unsigned int sign_CIFS_PDUs = 1;
66 extern struct task_struct *oplockThread; /* remove sparse warning */
67 struct task_struct *oplockThread = NULL;
68 /* extern struct task_struct * dnotifyThread; remove sparse warning */
69 static struct task_struct *dnotifyThread = NULL;
70 static const struct super_operations cifs_super_ops;
71 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
72 module_param(CIFSMaxBufSize, int, 0);
73 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
74 "Default: 16384 Range: 8192 to 130048");
75 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
76 module_param(cifs_min_rcv, int, 0);
77 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
79 unsigned int cifs_min_small = 30;
80 module_param(cifs_min_small, int, 0);
81 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
83 unsigned int cifs_max_pending = CIFS_MAX_REQ;
84 module_param(cifs_max_pending, int, 0);
85 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
86 "Default: 50 Range: 2 to 256");
88 extern mempool_t *cifs_sm_req_poolp;
89 extern mempool_t *cifs_req_poolp;
90 extern mempool_t *cifs_mid_poolp;
92 extern struct kmem_cache *cifs_oplock_cachep;
95 cifs_read_super(struct super_block *sb, void *data,
96 const char *devname, int silent)
99 struct cifs_sb_info *cifs_sb;
100 #ifdef CONFIG_CIFS_DFS_UPCALL
105 /* BB should we make this contingent on mount parm? */
106 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
107 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
108 cifs_sb = CIFS_SB(sb);
112 #ifdef CONFIG_CIFS_DFS_UPCALL
113 /* copy mount params to sb for use in submounts */
114 /* BB: should we move this after the mount so we
115 * do not have to do the copy on failed mounts?
116 * BB: May be it is better to do simple copy before
117 * complex operation (mount), and in case of fail
118 * just exit instead of doing mount and attempting
119 * undo it if this copy fails?*/
121 cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
122 if (cifs_sb->mountdata == NULL) {
123 kfree(sb->s_fs_info);
124 sb->s_fs_info = NULL;
127 strncpy(cifs_sb->mountdata, data, len + 1);
128 cifs_sb->mountdata[len] = '\0';
131 rc = cifs_mount(sb, cifs_sb, data, devname);
136 ("cifs_mount failed w/return code = %d", rc));
137 goto out_mount_failed;
140 sb->s_magic = CIFS_MAGIC_NUMBER;
141 sb->s_op = &cifs_super_ops;
142 /* if (cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
144 cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
145 #ifdef CONFIG_CIFS_QUOTA
146 sb->s_qcop = &cifs_quotactl_ops;
148 sb->s_blocksize = CIFS_MAX_MSGSIZE;
149 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
150 inode = cifs_iget(sb, ROOT_I);
158 sb->s_root = d_alloc_root(inode);
165 #ifdef CONFIG_CIFS_EXPERIMENTAL
166 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
167 cFYI(1, ("export ops supported"));
168 sb->s_export_op = &cifs_export_ops;
170 #endif /* EXPERIMENTAL */
175 cERROR(1, ("cifs_read_super: get root inode failed"));
181 #ifdef CONFIG_CIFS_DFS_UPCALL
182 if (cifs_sb->mountdata) {
183 kfree(cifs_sb->mountdata);
184 cifs_sb->mountdata = NULL;
187 if (cifs_sb->local_nls)
188 unload_nls(cifs_sb->local_nls);
195 cifs_put_super(struct super_block *sb)
198 struct cifs_sb_info *cifs_sb;
200 cFYI(1, ("In cifs_put_super"));
201 cifs_sb = CIFS_SB(sb);
202 if (cifs_sb == NULL) {
203 cFYI(1, ("Empty cifs superblock info passed to unmount"));
206 rc = cifs_umount(sb, cifs_sb);
208 cERROR(1, ("cifs_umount failed with return code %d", rc));
209 #ifdef CONFIG_CIFS_DFS_UPCALL
210 if (cifs_sb->mountdata) {
211 kfree(cifs_sb->mountdata);
212 cifs_sb->mountdata = NULL;
216 unload_nls(cifs_sb->local_nls);
222 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
224 struct super_block *sb = dentry->d_sb;
226 int rc = -EOPNOTSUPP;
227 struct cifs_sb_info *cifs_sb;
228 struct cifsTconInfo *pTcon;
232 cifs_sb = CIFS_SB(sb);
233 pTcon = cifs_sb->tcon;
235 buf->f_type = CIFS_MAGIC_NUMBER;
237 /* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */
238 buf->f_namelen = PATH_MAX; /* PATH_MAX may be too long - it would
239 presumably be total path, but note
240 that some servers (includinng Samba 3)
241 have a shorter maximum path */
242 buf->f_files = 0; /* undefined */
243 buf->f_ffree = 0; /* unlimited */
245 /* BB we could add a second check for a QFS Unix capability bit */
246 /* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */
247 if ((pTcon->ses->capabilities & CAP_UNIX) && (CIFS_POSIX_EXTENSIONS &
248 le64_to_cpu(pTcon->fsUnixInfo.Capability)))
249 rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf);
251 /* Only need to call the old QFSInfo if failed
254 if (pTcon->ses->capabilities & CAP_NT_SMBS)
255 rc = CIFSSMBQFSInfo(xid, pTcon, buf); /* not supported by OS2 */
257 /* Some old Windows servers also do not support level 103, retry with
258 older level one if old server failed the previous call or we
259 bypassed it because we detected that this was an older LANMAN sess */
261 rc = SMBOldQFSInfo(xid, pTcon, buf);
265 /* BB get from info in tcon struct at mount time call to QFSAttrInfo */
267 return 0; /* always return success? what if volume is no
271 static int cifs_permission(struct inode *inode, int mask, struct nameidata *nd)
273 struct cifs_sb_info *cifs_sb;
275 cifs_sb = CIFS_SB(inode->i_sb);
277 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
279 else /* file mode might have been restricted at mount time
280 on the client (above and beyond ACL on servers) for
281 servers which do not support setting and viewing mode bits,
282 so allowing client to check permissions is useful */
283 return generic_permission(inode, mask, NULL);
286 static struct kmem_cache *cifs_inode_cachep;
287 static struct kmem_cache *cifs_req_cachep;
288 static struct kmem_cache *cifs_mid_cachep;
289 struct kmem_cache *cifs_oplock_cachep;
290 static struct kmem_cache *cifs_sm_req_cachep;
291 mempool_t *cifs_sm_req_poolp;
292 mempool_t *cifs_req_poolp;
293 mempool_t *cifs_mid_poolp;
295 static struct inode *
296 cifs_alloc_inode(struct super_block *sb)
298 struct cifsInodeInfo *cifs_inode;
299 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
302 cifs_inode->cifsAttrs = 0x20; /* default */
303 atomic_set(&cifs_inode->inUse, 0);
304 cifs_inode->time = 0;
305 cifs_inode->write_behind_rc = 0;
306 /* Until the file is open and we have gotten oplock
307 info back from the server, can not assume caching of
308 file data or metadata */
309 cifs_inode->clientCanCacheRead = FALSE;
310 cifs_inode->clientCanCacheAll = FALSE;
311 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
313 /* Can not set i_flags here - they get immediately overwritten
314 to zero by the VFS */
315 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
316 INIT_LIST_HEAD(&cifs_inode->openFileList);
317 return &cifs_inode->vfs_inode;
321 cifs_destroy_inode(struct inode *inode)
323 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
327 * cifs_show_options() is for displaying mount options in /proc/mounts.
328 * Not all settable options are displayed but most of the important
332 cifs_show_options(struct seq_file *s, struct vfsmount *m)
334 struct cifs_sb_info *cifs_sb;
336 cifs_sb = CIFS_SB(m->mnt_sb);
340 /* BB add prepath to mount options displayed */
341 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
342 if (cifs_sb->tcon->ses) {
343 if (cifs_sb->tcon->ses->userName)
344 seq_printf(s, ",username=%s",
345 cifs_sb->tcon->ses->userName);
346 if (cifs_sb->tcon->ses->domainName)
347 seq_printf(s, ",domain=%s",
348 cifs_sb->tcon->ses->domainName);
350 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) ||
351 !(cifs_sb->tcon->unix_ext))
352 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
353 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) ||
354 !(cifs_sb->tcon->unix_ext))
355 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
357 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
358 seq_printf(s, ",posixpaths");
359 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
360 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
365 #ifdef CONFIG_CIFS_QUOTA
366 int cifs_xquota_set(struct super_block *sb, int quota_type, qid_t qid,
367 struct fs_disk_quota *pdquota)
371 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
372 struct cifsTconInfo *pTcon;
375 pTcon = cifs_sb->tcon;
382 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
391 int cifs_xquota_get(struct super_block *sb, int quota_type, qid_t qid,
392 struct fs_disk_quota *pdquota)
396 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
397 struct cifsTconInfo *pTcon;
400 pTcon = cifs_sb->tcon;
406 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
415 int cifs_xstate_set(struct super_block *sb, unsigned int flags, int operation)
419 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
420 struct cifsTconInfo *pTcon;
423 pTcon = cifs_sb->tcon;
429 cFYI(1, ("flags: 0x%x operation: 0x%x", flags, operation));
438 int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
442 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
443 struct cifsTconInfo *pTcon;
446 pTcon = cifs_sb->tcon;
452 cFYI(1, ("pqstats %p", qstats));
461 static struct quotactl_ops cifs_quotactl_ops = {
462 .set_xquota = cifs_xquota_set,
463 .get_xquota = cifs_xquota_get,
464 .set_xstate = cifs_xstate_set,
465 .get_xstate = cifs_xstate_get,
469 static void cifs_umount_begin(struct vfsmount *vfsmnt, int flags)
471 struct cifs_sb_info *cifs_sb;
472 struct cifsTconInfo *tcon;
474 if (!(flags & MNT_FORCE))
476 cifs_sb = CIFS_SB(vfsmnt->mnt_sb);
480 tcon = cifs_sb->tcon;
483 down(&tcon->tconSem);
484 if (atomic_read(&tcon->useCount) == 1)
485 tcon->tidStatus = CifsExiting;
488 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
489 /* cancel_notify_requests(tcon); */
490 if (tcon->ses && tcon->ses->server) {
491 cFYI(1, ("wake up tasks now - umount begin not complete"));
492 wake_up_all(&tcon->ses->server->request_q);
493 wake_up_all(&tcon->ses->server->response_q);
494 msleep(1); /* yield */
495 /* we have to kick the requests once more */
496 wake_up_all(&tcon->ses->server->response_q);
499 /* BB FIXME - finish add checks for tidStatus BB */
504 #ifdef CONFIG_CIFS_STATS2
505 static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
512 static int cifs_remount(struct super_block *sb, int *flags, char *data)
514 *flags |= MS_NODIRATIME;
518 static const struct super_operations cifs_super_ops = {
519 .put_super = cifs_put_super,
520 .statfs = cifs_statfs,
521 .alloc_inode = cifs_alloc_inode,
522 .destroy_inode = cifs_destroy_inode,
523 /* .drop_inode = generic_delete_inode,
524 .delete_inode = cifs_delete_inode, */ /* Do not need above two
525 functions unless later we add lazy close of inodes or unless the
526 kernel forgets to call us with the same number of releases (closes)
528 .show_options = cifs_show_options,
529 .umount_begin = cifs_umount_begin,
530 .remount_fs = cifs_remount,
531 #ifdef CONFIG_CIFS_STATS2
532 .show_stats = cifs_show_stats,
537 cifs_get_sb(struct file_system_type *fs_type,
538 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
541 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
543 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
550 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
552 up_write(&sb->s_umount);
553 deactivate_super(sb);
556 sb->s_flags |= MS_ACTIVE;
557 return simple_set_mnt(mnt, sb);
560 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
561 unsigned long nr_segs, loff_t pos)
563 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
566 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
567 if (!CIFS_I(inode)->clientCanCacheAll)
568 filemap_fdatawrite(inode->i_mapping);
572 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
574 /* origin == SEEK_END => we must revalidate the cached file length */
575 if (origin == SEEK_END) {
578 /* some applications poll for the file length in this strange
579 way so we must seek to end on non-oplocked files by
580 setting the revalidate time to zero */
581 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
583 retval = cifs_revalidate(file->f_path.dentry);
585 return (loff_t)retval;
587 return remote_llseek(file, offset, origin);
590 struct file_system_type cifs_fs_type = {
591 .owner = THIS_MODULE,
593 .get_sb = cifs_get_sb,
594 .kill_sb = kill_anon_super,
597 const struct inode_operations cifs_dir_inode_ops = {
598 .create = cifs_create,
599 .lookup = cifs_lookup,
600 .getattr = cifs_getattr,
601 .unlink = cifs_unlink,
602 .link = cifs_hardlink,
605 .rename = cifs_rename,
606 .permission = cifs_permission,
607 /* revalidate:cifs_revalidate, */
608 .setattr = cifs_setattr,
609 .symlink = cifs_symlink,
611 #ifdef CONFIG_CIFS_XATTR
612 .setxattr = cifs_setxattr,
613 .getxattr = cifs_getxattr,
614 .listxattr = cifs_listxattr,
615 .removexattr = cifs_removexattr,
619 const struct inode_operations cifs_file_inode_ops = {
620 /* revalidate:cifs_revalidate, */
621 .setattr = cifs_setattr,
622 .getattr = cifs_getattr, /* do we need this anymore? */
623 .rename = cifs_rename,
624 .permission = cifs_permission,
625 #ifdef CONFIG_CIFS_XATTR
626 .setxattr = cifs_setxattr,
627 .getxattr = cifs_getxattr,
628 .listxattr = cifs_listxattr,
629 .removexattr = cifs_removexattr,
633 const struct inode_operations cifs_symlink_inode_ops = {
634 .readlink = generic_readlink,
635 .follow_link = cifs_follow_link,
636 .put_link = cifs_put_link,
637 .permission = cifs_permission,
638 /* BB add the following two eventually */
639 /* revalidate: cifs_revalidate,
640 setattr: cifs_notify_change, *//* BB do we need notify change */
641 #ifdef CONFIG_CIFS_XATTR
642 .setxattr = cifs_setxattr,
643 .getxattr = cifs_getxattr,
644 .listxattr = cifs_listxattr,
645 .removexattr = cifs_removexattr,
649 const struct file_operations cifs_file_ops = {
650 .read = do_sync_read,
651 .write = do_sync_write,
652 .aio_read = generic_file_aio_read,
653 .aio_write = cifs_file_aio_write,
655 .release = cifs_close,
659 .mmap = cifs_file_mmap,
660 .splice_read = generic_file_splice_read,
661 .llseek = cifs_llseek,
662 #ifdef CONFIG_CIFS_POSIX
664 #endif /* CONFIG_CIFS_POSIX */
666 #ifdef CONFIG_CIFS_EXPERIMENTAL
667 .dir_notify = cifs_dir_notify,
668 #endif /* CONFIG_CIFS_EXPERIMENTAL */
671 const struct file_operations cifs_file_direct_ops = {
672 /* no mmap, no aio, no readv -
673 BB reevaluate whether they can be done with directio, no cache */
674 .read = cifs_user_read,
675 .write = cifs_user_write,
677 .release = cifs_close,
681 .splice_read = generic_file_splice_read,
682 #ifdef CONFIG_CIFS_POSIX
684 #endif /* CONFIG_CIFS_POSIX */
685 .llseek = cifs_llseek,
686 #ifdef CONFIG_CIFS_EXPERIMENTAL
687 .dir_notify = cifs_dir_notify,
688 #endif /* CONFIG_CIFS_EXPERIMENTAL */
690 const struct file_operations cifs_file_nobrl_ops = {
691 .read = do_sync_read,
692 .write = do_sync_write,
693 .aio_read = generic_file_aio_read,
694 .aio_write = cifs_file_aio_write,
696 .release = cifs_close,
699 .mmap = cifs_file_mmap,
700 .splice_read = generic_file_splice_read,
701 .llseek = cifs_llseek,
702 #ifdef CONFIG_CIFS_POSIX
704 #endif /* CONFIG_CIFS_POSIX */
706 #ifdef CONFIG_CIFS_EXPERIMENTAL
707 .dir_notify = cifs_dir_notify,
708 #endif /* CONFIG_CIFS_EXPERIMENTAL */
711 const struct file_operations cifs_file_direct_nobrl_ops = {
712 /* no mmap, no aio, no readv -
713 BB reevaluate whether they can be done with directio, no cache */
714 .read = cifs_user_read,
715 .write = cifs_user_write,
717 .release = cifs_close,
720 .splice_read = generic_file_splice_read,
721 #ifdef CONFIG_CIFS_POSIX
723 #endif /* CONFIG_CIFS_POSIX */
724 .llseek = cifs_llseek,
725 #ifdef CONFIG_CIFS_EXPERIMENTAL
726 .dir_notify = cifs_dir_notify,
727 #endif /* CONFIG_CIFS_EXPERIMENTAL */
730 const struct file_operations cifs_dir_ops = {
731 .readdir = cifs_readdir,
732 .release = cifs_closedir,
733 .read = generic_read_dir,
734 #ifdef CONFIG_CIFS_EXPERIMENTAL
735 .dir_notify = cifs_dir_notify,
736 #endif /* CONFIG_CIFS_EXPERIMENTAL */
741 cifs_init_once(struct kmem_cache *cachep, void *inode)
743 struct cifsInodeInfo *cifsi = inode;
745 inode_init_once(&cifsi->vfs_inode);
746 INIT_LIST_HEAD(&cifsi->lockList);
750 cifs_init_inodecache(void)
752 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
753 sizeof(struct cifsInodeInfo),
754 0, (SLAB_RECLAIM_ACCOUNT|
757 if (cifs_inode_cachep == NULL)
764 cifs_destroy_inodecache(void)
766 kmem_cache_destroy(cifs_inode_cachep);
770 cifs_init_request_bufs(void)
772 if (CIFSMaxBufSize < 8192) {
773 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
774 Unicode path name has to fit in any SMB/CIFS path based frames */
775 CIFSMaxBufSize = 8192;
776 } else if (CIFSMaxBufSize > 1024*127) {
777 CIFSMaxBufSize = 1024 * 127;
779 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
781 /* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
782 cifs_req_cachep = kmem_cache_create("cifs_request",
784 MAX_CIFS_HDR_SIZE, 0,
785 SLAB_HWCACHE_ALIGN, NULL);
786 if (cifs_req_cachep == NULL)
789 if (cifs_min_rcv < 1)
791 else if (cifs_min_rcv > 64) {
793 cERROR(1, ("cifs_min_rcv set to maximum (64)"));
796 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
799 if (cifs_req_poolp == NULL) {
800 kmem_cache_destroy(cifs_req_cachep);
803 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
804 almost all handle based requests (but not write response, nor is it
805 sufficient for path based requests). A smaller size would have
806 been more efficient (compacting multiple slab items on one 4k page)
807 for the case in which debug was on, but this larger size allows
808 more SMBs to use small buffer alloc and is still much more
809 efficient to alloc 1 per page off the slab compared to 17K (5page)
810 alloc of large cifs buffers even when page debugging is on */
811 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
812 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
814 if (cifs_sm_req_cachep == NULL) {
815 mempool_destroy(cifs_req_poolp);
816 kmem_cache_destroy(cifs_req_cachep);
820 if (cifs_min_small < 2)
822 else if (cifs_min_small > 256) {
823 cifs_min_small = 256;
824 cFYI(1, ("cifs_min_small set to maximum (256)"));
827 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
830 if (cifs_sm_req_poolp == NULL) {
831 mempool_destroy(cifs_req_poolp);
832 kmem_cache_destroy(cifs_req_cachep);
833 kmem_cache_destroy(cifs_sm_req_cachep);
841 cifs_destroy_request_bufs(void)
843 mempool_destroy(cifs_req_poolp);
844 kmem_cache_destroy(cifs_req_cachep);
845 mempool_destroy(cifs_sm_req_poolp);
846 kmem_cache_destroy(cifs_sm_req_cachep);
852 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
853 sizeof(struct mid_q_entry), 0,
854 SLAB_HWCACHE_ALIGN, NULL);
855 if (cifs_mid_cachep == NULL)
858 /* 3 is a reasonable minimum number of simultaneous operations */
859 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
860 if (cifs_mid_poolp == NULL) {
861 kmem_cache_destroy(cifs_mid_cachep);
865 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
866 sizeof(struct oplock_q_entry), 0,
867 SLAB_HWCACHE_ALIGN, NULL);
868 if (cifs_oplock_cachep == NULL) {
869 mempool_destroy(cifs_mid_poolp);
870 kmem_cache_destroy(cifs_mid_cachep);
878 cifs_destroy_mids(void)
880 mempool_destroy(cifs_mid_poolp);
881 kmem_cache_destroy(cifs_mid_cachep);
882 kmem_cache_destroy(cifs_oplock_cachep);
885 static int cifs_oplock_thread(void *dummyarg)
887 struct oplock_q_entry *oplock_item;
888 struct cifsTconInfo *pTcon;
898 spin_lock(&GlobalMid_Lock);
899 if (list_empty(&GlobalOplock_Q)) {
900 spin_unlock(&GlobalMid_Lock);
901 set_current_state(TASK_INTERRUPTIBLE);
902 schedule_timeout(39*HZ);
904 oplock_item = list_entry(GlobalOplock_Q.next,
905 struct oplock_q_entry, qhead);
907 cFYI(1, ("found oplock item to write out"));
908 pTcon = oplock_item->tcon;
909 inode = oplock_item->pinode;
910 netfid = oplock_item->netfid;
911 spin_unlock(&GlobalMid_Lock);
912 DeleteOplockQEntry(oplock_item);
913 /* can not grab inode sem here since it would
914 deadlock when oplock received on delete
915 since vfs_unlink holds the i_mutex across
917 /* mutex_lock(&inode->i_mutex);*/
918 if (S_ISREG(inode->i_mode)) {
920 filemap_fdatawrite(inode->i_mapping);
921 if (CIFS_I(inode)->clientCanCacheRead
923 waitrc = filemap_fdatawait(inode->i_mapping);
924 invalidate_remote_inode(inode);
930 /* mutex_unlock(&inode->i_mutex);*/
932 CIFS_I(inode)->write_behind_rc = rc;
933 cFYI(1, ("Oplock flush inode %p rc %d",
936 /* releasing stale oplock after recent reconnect
937 of smb session using a now incorrect file
938 handle is not a data integrity issue but do
939 not bother sending an oplock release if session
940 to server still is disconnected since oplock
941 already released by the server in that case */
942 if (pTcon->tidStatus != CifsNeedReconnect) {
943 rc = CIFSSMBLock(0, pTcon, netfid,
944 0 /* len */ , 0 /* offset */, 0,
945 0, LOCKING_ANDX_OPLOCK_RELEASE,
947 cFYI(1, ("Oplock release rc = %d", rc));
950 spin_unlock(&GlobalMid_Lock);
951 set_current_state(TASK_INTERRUPTIBLE);
952 schedule_timeout(1); /* yield in case q were corrupt */
954 } while (!kthread_should_stop());
959 static int cifs_dnotify_thread(void *dummyarg)
961 struct list_head *tmp;
962 struct cifsSesInfo *ses;
967 set_current_state(TASK_INTERRUPTIBLE);
968 schedule_timeout(15*HZ);
969 read_lock(&GlobalSMBSeslock);
970 /* check if any stuck requests that need
971 to be woken up and wakeq so the
972 thread can wake up and error out */
973 list_for_each(tmp, &GlobalSMBSessionList) {
974 ses = list_entry(tmp, struct cifsSesInfo,
976 if (ses && ses->server &&
977 atomic_read(&ses->server->inFlight))
978 wake_up_all(&ses->server->response_q);
980 read_unlock(&GlobalSMBSeslock);
981 } while (!kthread_should_stop());
991 /* INIT_LIST_HEAD(&GlobalServerList);*/ /* BB not implemented yet */
992 INIT_LIST_HEAD(&GlobalSMBSessionList);
993 INIT_LIST_HEAD(&GlobalTreeConnectionList);
994 INIT_LIST_HEAD(&GlobalOplock_Q);
995 #ifdef CONFIG_CIFS_EXPERIMENTAL
996 INIT_LIST_HEAD(&GlobalDnotifyReqList);
997 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1000 * Initialize Global counters
1002 atomic_set(&sesInfoAllocCount, 0);
1003 atomic_set(&tconInfoAllocCount, 0);
1004 atomic_set(&tcpSesAllocCount, 0);
1005 atomic_set(&tcpSesReconnectCount, 0);
1006 atomic_set(&tconInfoReconnectCount, 0);
1008 atomic_set(&bufAllocCount, 0);
1009 atomic_set(&smBufAllocCount, 0);
1010 #ifdef CONFIG_CIFS_STATS2
1011 atomic_set(&totBufAllocCount, 0);
1012 atomic_set(&totSmBufAllocCount, 0);
1013 #endif /* CONFIG_CIFS_STATS2 */
1015 atomic_set(&midCount, 0);
1016 GlobalCurrentXid = 0;
1017 GlobalTotalActiveXid = 0;
1018 GlobalMaxActiveXid = 0;
1019 memset(Local_System_Name, 0, 15);
1020 rwlock_init(&GlobalSMBSeslock);
1021 spin_lock_init(&GlobalMid_Lock);
1023 if (cifs_max_pending < 2) {
1024 cifs_max_pending = 2;
1025 cFYI(1, ("cifs_max_pending set to min of 2"));
1026 } else if (cifs_max_pending > 256) {
1027 cifs_max_pending = 256;
1028 cFYI(1, ("cifs_max_pending set to max of 256"));
1031 rc = cifs_init_inodecache();
1033 goto out_clean_proc;
1035 rc = cifs_init_mids();
1037 goto out_destroy_inodecache;
1039 rc = cifs_init_request_bufs();
1041 goto out_destroy_mids;
1043 rc = register_filesystem(&cifs_fs_type);
1045 goto out_destroy_request_bufs;
1046 #ifdef CONFIG_CIFS_UPCALL
1047 rc = register_key_type(&cifs_spnego_key_type);
1049 goto out_unregister_filesystem;
1051 #ifdef CONFIG_CIFS_DFS_UPCALL
1052 rc = register_key_type(&key_type_dns_resolver);
1054 goto out_unregister_key_type;
1056 oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
1057 if (IS_ERR(oplockThread)) {
1058 rc = PTR_ERR(oplockThread);
1059 cERROR(1, ("error %d create oplock thread", rc));
1060 goto out_unregister_dfs_key_type;
1063 dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
1064 if (IS_ERR(dnotifyThread)) {
1065 rc = PTR_ERR(dnotifyThread);
1066 cERROR(1, ("error %d create dnotify thread", rc));
1067 goto out_stop_oplock_thread;
1072 out_stop_oplock_thread:
1073 kthread_stop(oplockThread);
1074 out_unregister_dfs_key_type:
1075 #ifdef CONFIG_CIFS_DFS_UPCALL
1076 unregister_key_type(&key_type_dns_resolver);
1077 out_unregister_key_type:
1079 #ifdef CONFIG_CIFS_UPCALL
1080 unregister_key_type(&cifs_spnego_key_type);
1081 out_unregister_filesystem:
1083 unregister_filesystem(&cifs_fs_type);
1084 out_destroy_request_bufs:
1085 cifs_destroy_request_bufs();
1087 cifs_destroy_mids();
1088 out_destroy_inodecache:
1089 cifs_destroy_inodecache();
1098 cFYI(DBG2, ("exit_cifs"));
1100 #ifdef CONFIG_CIFS_DFS_UPCALL
1101 cifs_dfs_release_automount_timer();
1102 unregister_key_type(&key_type_dns_resolver);
1104 #ifdef CONFIG_CIFS_UPCALL
1105 unregister_key_type(&cifs_spnego_key_type);
1107 unregister_filesystem(&cifs_fs_type);
1108 cifs_destroy_inodecache();
1109 cifs_destroy_mids();
1110 cifs_destroy_request_bufs();
1111 kthread_stop(oplockThread);
1112 kthread_stop(dnotifyThread);
1115 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1116 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1118 ("VFS to access servers complying with the SNIA CIFS Specification "
1119 "e.g. Samba and Windows");
1120 MODULE_VERSION(CIFS_VERSION);
1121 module_init(init_cifs)
1122 module_exit(exit_cifs)