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 = iget(sb, ROOT_I);
157 sb->s_root = d_alloc_root(inode);
164 #ifdef CONFIG_CIFS_EXPERIMENTAL
165 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
166 cFYI(1, ("export ops supported"));
167 sb->s_export_op = &cifs_export_ops;
169 #endif /* EXPERIMENTAL */
174 cERROR(1, ("cifs_read_super: get root inode failed"));
180 #ifdef CONFIG_CIFS_DFS_UPCALL
181 if (cifs_sb->mountdata) {
182 kfree(cifs_sb->mountdata);
183 cifs_sb->mountdata = NULL;
186 if (cifs_sb->local_nls)
187 unload_nls(cifs_sb->local_nls);
194 cifs_put_super(struct super_block *sb)
197 struct cifs_sb_info *cifs_sb;
199 cFYI(1, ("In cifs_put_super"));
200 cifs_sb = CIFS_SB(sb);
201 if (cifs_sb == NULL) {
202 cFYI(1, ("Empty cifs superblock info passed to unmount"));
205 rc = cifs_umount(sb, cifs_sb);
207 cERROR(1, ("cifs_umount failed with return code %d", rc));
208 #ifdef CONFIG_CIFS_DFS_UPCALL
209 if (cifs_sb->mountdata) {
210 kfree(cifs_sb->mountdata);
211 cifs_sb->mountdata = NULL;
215 unload_nls(cifs_sb->local_nls);
221 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
223 struct super_block *sb = dentry->d_sb;
225 int rc = -EOPNOTSUPP;
226 struct cifs_sb_info *cifs_sb;
227 struct cifsTconInfo *pTcon;
231 cifs_sb = CIFS_SB(sb);
232 pTcon = cifs_sb->tcon;
234 buf->f_type = CIFS_MAGIC_NUMBER;
236 /* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */
237 buf->f_namelen = PATH_MAX; /* PATH_MAX may be too long - it would
238 presumably be total path, but note
239 that some servers (includinng Samba 3)
240 have a shorter maximum path */
241 buf->f_files = 0; /* undefined */
242 buf->f_ffree = 0; /* unlimited */
244 /* BB we could add a second check for a QFS Unix capability bit */
245 /* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */
246 if ((pTcon->ses->capabilities & CAP_UNIX) && (CIFS_POSIX_EXTENSIONS &
247 le64_to_cpu(pTcon->fsUnixInfo.Capability)))
248 rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf);
250 /* Only need to call the old QFSInfo if failed
253 if (pTcon->ses->capabilities & CAP_NT_SMBS)
254 rc = CIFSSMBQFSInfo(xid, pTcon, buf); /* not supported by OS2 */
256 /* Some old Windows servers also do not support level 103, retry with
257 older level one if old server failed the previous call or we
258 bypassed it because we detected that this was an older LANMAN sess */
260 rc = SMBOldQFSInfo(xid, pTcon, buf);
264 /* BB get from info in tcon struct at mount time call to QFSAttrInfo */
266 return 0; /* always return success? what if volume is no
270 static int cifs_permission(struct inode *inode, int mask, struct nameidata *nd)
272 struct cifs_sb_info *cifs_sb;
274 cifs_sb = CIFS_SB(inode->i_sb);
276 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
278 else /* file mode might have been restricted at mount time
279 on the client (above and beyond ACL on servers) for
280 servers which do not support setting and viewing mode bits,
281 so allowing client to check permissions is useful */
282 return generic_permission(inode, mask, NULL);
285 static struct kmem_cache *cifs_inode_cachep;
286 static struct kmem_cache *cifs_req_cachep;
287 static struct kmem_cache *cifs_mid_cachep;
288 struct kmem_cache *cifs_oplock_cachep;
289 static struct kmem_cache *cifs_sm_req_cachep;
290 mempool_t *cifs_sm_req_poolp;
291 mempool_t *cifs_req_poolp;
292 mempool_t *cifs_mid_poolp;
294 static struct inode *
295 cifs_alloc_inode(struct super_block *sb)
297 struct cifsInodeInfo *cifs_inode;
298 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
301 cifs_inode->cifsAttrs = 0x20; /* default */
302 atomic_set(&cifs_inode->inUse, 0);
303 cifs_inode->time = 0;
304 cifs_inode->write_behind_rc = 0;
305 /* Until the file is open and we have gotten oplock
306 info back from the server, can not assume caching of
307 file data or metadata */
308 cifs_inode->clientCanCacheRead = FALSE;
309 cifs_inode->clientCanCacheAll = FALSE;
310 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
312 /* Can not set i_flags here - they get immediately overwritten
313 to zero by the VFS */
314 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
315 INIT_LIST_HEAD(&cifs_inode->openFileList);
316 return &cifs_inode->vfs_inode;
320 cifs_destroy_inode(struct inode *inode)
322 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
326 * cifs_show_options() is for displaying mount options in /proc/mounts.
327 * Not all settable options are displayed but most of the important
331 cifs_show_options(struct seq_file *s, struct vfsmount *m)
333 struct cifs_sb_info *cifs_sb;
335 cifs_sb = CIFS_SB(m->mnt_sb);
339 /* BB add prepath to mount options displayed */
340 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
341 if (cifs_sb->tcon->ses) {
342 if (cifs_sb->tcon->ses->userName)
343 seq_printf(s, ",username=%s",
344 cifs_sb->tcon->ses->userName);
345 if (cifs_sb->tcon->ses->domainName)
346 seq_printf(s, ",domain=%s",
347 cifs_sb->tcon->ses->domainName);
349 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) ||
350 !(cifs_sb->tcon->unix_ext))
351 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
352 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) ||
353 !(cifs_sb->tcon->unix_ext))
354 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
356 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
357 seq_printf(s, ",posixpaths");
358 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
359 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
364 #ifdef CONFIG_CIFS_QUOTA
365 int cifs_xquota_set(struct super_block *sb, int quota_type, qid_t qid,
366 struct fs_disk_quota *pdquota)
370 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
371 struct cifsTconInfo *pTcon;
374 pTcon = cifs_sb->tcon;
381 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
390 int cifs_xquota_get(struct super_block *sb, int quota_type, qid_t qid,
391 struct fs_disk_quota *pdquota)
395 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
396 struct cifsTconInfo *pTcon;
399 pTcon = cifs_sb->tcon;
405 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
414 int cifs_xstate_set(struct super_block *sb, unsigned int flags, int operation)
418 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
419 struct cifsTconInfo *pTcon;
422 pTcon = cifs_sb->tcon;
428 cFYI(1, ("flags: 0x%x operation: 0x%x", flags, operation));
437 int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
441 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
442 struct cifsTconInfo *pTcon;
445 pTcon = cifs_sb->tcon;
451 cFYI(1, ("pqstats %p", qstats));
460 static struct quotactl_ops cifs_quotactl_ops = {
461 .set_xquota = cifs_xquota_set,
462 .get_xquota = cifs_xquota_set,
463 .set_xstate = cifs_xstate_set,
464 .get_xstate = cifs_xstate_get,
468 static void cifs_umount_begin(struct vfsmount *vfsmnt, int flags)
470 struct cifs_sb_info *cifs_sb;
471 struct cifsTconInfo *tcon;
473 #ifdef CONFIG_CIFS_DFS_UPCALL
474 dfs_shrink_umount_helper(vfsmnt);
475 #endif /* CONFIG CIFS_DFS_UPCALL */
477 if (!(flags & MNT_FORCE))
479 cifs_sb = CIFS_SB(vfsmnt->mnt_sb);
483 tcon = cifs_sb->tcon;
486 down(&tcon->tconSem);
487 if (atomic_read(&tcon->useCount) == 1)
488 tcon->tidStatus = CifsExiting;
491 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
492 /* cancel_notify_requests(tcon); */
493 if (tcon->ses && tcon->ses->server) {
494 cFYI(1, ("wake up tasks now - umount begin not complete"));
495 wake_up_all(&tcon->ses->server->request_q);
496 wake_up_all(&tcon->ses->server->response_q);
497 msleep(1); /* yield */
498 /* we have to kick the requests once more */
499 wake_up_all(&tcon->ses->server->response_q);
502 /* BB FIXME - finish add checks for tidStatus BB */
507 #ifdef CONFIG_CIFS_STATS2
508 static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
515 static int cifs_remount(struct super_block *sb, int *flags, char *data)
517 *flags |= MS_NODIRATIME;
521 static const struct super_operations cifs_super_ops = {
522 .read_inode = cifs_read_inode,
523 .put_super = cifs_put_super,
524 .statfs = cifs_statfs,
525 .alloc_inode = cifs_alloc_inode,
526 .destroy_inode = cifs_destroy_inode,
527 /* .drop_inode = generic_delete_inode,
528 .delete_inode = cifs_delete_inode, */ /* Do not need above two
529 functions unless later we add lazy close of inodes or unless the
530 kernel forgets to call us with the same number of releases (closes)
532 .show_options = cifs_show_options,
533 .umount_begin = cifs_umount_begin,
534 .remount_fs = cifs_remount,
535 #ifdef CONFIG_CIFS_STATS2
536 .show_stats = cifs_show_stats,
541 cifs_get_sb(struct file_system_type *fs_type,
542 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
545 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
547 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
554 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
556 up_write(&sb->s_umount);
557 deactivate_super(sb);
560 sb->s_flags |= MS_ACTIVE;
561 return simple_set_mnt(mnt, sb);
564 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
565 unsigned long nr_segs, loff_t pos)
567 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
570 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
571 if (!CIFS_I(inode)->clientCanCacheAll)
572 filemap_fdatawrite(inode->i_mapping);
576 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
578 /* origin == SEEK_END => we must revalidate the cached file length */
579 if (origin == SEEK_END) {
582 /* some applications poll for the file length in this strange
583 way so we must seek to end on non-oplocked files by
584 setting the revalidate time to zero */
585 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
587 retval = cifs_revalidate(file->f_path.dentry);
589 return (loff_t)retval;
591 return remote_llseek(file, offset, origin);
594 struct file_system_type cifs_fs_type = {
595 .owner = THIS_MODULE,
597 .get_sb = cifs_get_sb,
598 .kill_sb = kill_anon_super,
601 const struct inode_operations cifs_dir_inode_ops = {
602 .create = cifs_create,
603 .lookup = cifs_lookup,
604 .getattr = cifs_getattr,
605 .unlink = cifs_unlink,
606 .link = cifs_hardlink,
609 .rename = cifs_rename,
610 .permission = cifs_permission,
611 /* revalidate:cifs_revalidate, */
612 .setattr = cifs_setattr,
613 .symlink = cifs_symlink,
615 #ifdef CONFIG_CIFS_XATTR
616 .setxattr = cifs_setxattr,
617 .getxattr = cifs_getxattr,
618 .listxattr = cifs_listxattr,
619 .removexattr = cifs_removexattr,
623 const struct inode_operations cifs_file_inode_ops = {
624 /* revalidate:cifs_revalidate, */
625 .setattr = cifs_setattr,
626 .getattr = cifs_getattr, /* do we need this anymore? */
627 .rename = cifs_rename,
628 .permission = cifs_permission,
629 #ifdef CONFIG_CIFS_XATTR
630 .setxattr = cifs_setxattr,
631 .getxattr = cifs_getxattr,
632 .listxattr = cifs_listxattr,
633 .removexattr = cifs_removexattr,
637 const struct inode_operations cifs_symlink_inode_ops = {
638 .readlink = generic_readlink,
639 .follow_link = cifs_follow_link,
640 .put_link = cifs_put_link,
641 .permission = cifs_permission,
642 /* BB add the following two eventually */
643 /* revalidate: cifs_revalidate,
644 setattr: cifs_notify_change, *//* BB do we need notify change */
645 #ifdef CONFIG_CIFS_XATTR
646 .setxattr = cifs_setxattr,
647 .getxattr = cifs_getxattr,
648 .listxattr = cifs_listxattr,
649 .removexattr = cifs_removexattr,
653 const struct file_operations cifs_file_ops = {
654 .read = do_sync_read,
655 .write = do_sync_write,
656 .aio_read = generic_file_aio_read,
657 .aio_write = cifs_file_aio_write,
659 .release = cifs_close,
663 .mmap = cifs_file_mmap,
664 .splice_read = generic_file_splice_read,
665 .llseek = cifs_llseek,
666 #ifdef CONFIG_CIFS_POSIX
668 #endif /* CONFIG_CIFS_POSIX */
670 #ifdef CONFIG_CIFS_EXPERIMENTAL
671 .dir_notify = cifs_dir_notify,
672 #endif /* CONFIG_CIFS_EXPERIMENTAL */
675 const struct file_operations cifs_file_direct_ops = {
676 /* no mmap, no aio, no readv -
677 BB reevaluate whether they can be done with directio, no cache */
678 .read = cifs_user_read,
679 .write = cifs_user_write,
681 .release = cifs_close,
685 .splice_read = generic_file_splice_read,
686 #ifdef CONFIG_CIFS_POSIX
688 #endif /* CONFIG_CIFS_POSIX */
689 .llseek = cifs_llseek,
690 #ifdef CONFIG_CIFS_EXPERIMENTAL
691 .dir_notify = cifs_dir_notify,
692 #endif /* CONFIG_CIFS_EXPERIMENTAL */
694 const struct file_operations cifs_file_nobrl_ops = {
695 .read = do_sync_read,
696 .write = do_sync_write,
697 .aio_read = generic_file_aio_read,
698 .aio_write = cifs_file_aio_write,
700 .release = cifs_close,
703 .mmap = cifs_file_mmap,
704 .splice_read = generic_file_splice_read,
705 .llseek = cifs_llseek,
706 #ifdef CONFIG_CIFS_POSIX
708 #endif /* CONFIG_CIFS_POSIX */
710 #ifdef CONFIG_CIFS_EXPERIMENTAL
711 .dir_notify = cifs_dir_notify,
712 #endif /* CONFIG_CIFS_EXPERIMENTAL */
715 const struct file_operations cifs_file_direct_nobrl_ops = {
716 /* no mmap, no aio, no readv -
717 BB reevaluate whether they can be done with directio, no cache */
718 .read = cifs_user_read,
719 .write = cifs_user_write,
721 .release = cifs_close,
724 .splice_read = generic_file_splice_read,
725 #ifdef CONFIG_CIFS_POSIX
727 #endif /* CONFIG_CIFS_POSIX */
728 .llseek = cifs_llseek,
729 #ifdef CONFIG_CIFS_EXPERIMENTAL
730 .dir_notify = cifs_dir_notify,
731 #endif /* CONFIG_CIFS_EXPERIMENTAL */
734 const struct file_operations cifs_dir_ops = {
735 .readdir = cifs_readdir,
736 .release = cifs_closedir,
737 .read = generic_read_dir,
738 #ifdef CONFIG_CIFS_EXPERIMENTAL
739 .dir_notify = cifs_dir_notify,
740 #endif /* CONFIG_CIFS_EXPERIMENTAL */
745 cifs_init_once(struct kmem_cache *cachep, void *inode)
747 struct cifsInodeInfo *cifsi = inode;
749 inode_init_once(&cifsi->vfs_inode);
750 INIT_LIST_HEAD(&cifsi->lockList);
754 cifs_init_inodecache(void)
756 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
757 sizeof(struct cifsInodeInfo),
758 0, (SLAB_RECLAIM_ACCOUNT|
761 if (cifs_inode_cachep == NULL)
768 cifs_destroy_inodecache(void)
770 kmem_cache_destroy(cifs_inode_cachep);
774 cifs_init_request_bufs(void)
776 if (CIFSMaxBufSize < 8192) {
777 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
778 Unicode path name has to fit in any SMB/CIFS path based frames */
779 CIFSMaxBufSize = 8192;
780 } else if (CIFSMaxBufSize > 1024*127) {
781 CIFSMaxBufSize = 1024 * 127;
783 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
785 /* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
786 cifs_req_cachep = kmem_cache_create("cifs_request",
788 MAX_CIFS_HDR_SIZE, 0,
789 SLAB_HWCACHE_ALIGN, NULL);
790 if (cifs_req_cachep == NULL)
793 if (cifs_min_rcv < 1)
795 else if (cifs_min_rcv > 64) {
797 cERROR(1, ("cifs_min_rcv set to maximum (64)"));
800 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
803 if (cifs_req_poolp == NULL) {
804 kmem_cache_destroy(cifs_req_cachep);
807 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
808 almost all handle based requests (but not write response, nor is it
809 sufficient for path based requests). A smaller size would have
810 been more efficient (compacting multiple slab items on one 4k page)
811 for the case in which debug was on, but this larger size allows
812 more SMBs to use small buffer alloc and is still much more
813 efficient to alloc 1 per page off the slab compared to 17K (5page)
814 alloc of large cifs buffers even when page debugging is on */
815 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
816 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
818 if (cifs_sm_req_cachep == NULL) {
819 mempool_destroy(cifs_req_poolp);
820 kmem_cache_destroy(cifs_req_cachep);
824 if (cifs_min_small < 2)
826 else if (cifs_min_small > 256) {
827 cifs_min_small = 256;
828 cFYI(1, ("cifs_min_small set to maximum (256)"));
831 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
834 if (cifs_sm_req_poolp == NULL) {
835 mempool_destroy(cifs_req_poolp);
836 kmem_cache_destroy(cifs_req_cachep);
837 kmem_cache_destroy(cifs_sm_req_cachep);
845 cifs_destroy_request_bufs(void)
847 mempool_destroy(cifs_req_poolp);
848 kmem_cache_destroy(cifs_req_cachep);
849 mempool_destroy(cifs_sm_req_poolp);
850 kmem_cache_destroy(cifs_sm_req_cachep);
856 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
857 sizeof(struct mid_q_entry), 0,
858 SLAB_HWCACHE_ALIGN, NULL);
859 if (cifs_mid_cachep == NULL)
862 /* 3 is a reasonable minimum number of simultaneous operations */
863 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
864 if (cifs_mid_poolp == NULL) {
865 kmem_cache_destroy(cifs_mid_cachep);
869 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
870 sizeof(struct oplock_q_entry), 0,
871 SLAB_HWCACHE_ALIGN, NULL);
872 if (cifs_oplock_cachep == NULL) {
873 mempool_destroy(cifs_mid_poolp);
874 kmem_cache_destroy(cifs_mid_cachep);
882 cifs_destroy_mids(void)
884 mempool_destroy(cifs_mid_poolp);
885 kmem_cache_destroy(cifs_mid_cachep);
886 kmem_cache_destroy(cifs_oplock_cachep);
889 static int cifs_oplock_thread(void *dummyarg)
891 struct oplock_q_entry *oplock_item;
892 struct cifsTconInfo *pTcon;
902 spin_lock(&GlobalMid_Lock);
903 if (list_empty(&GlobalOplock_Q)) {
904 spin_unlock(&GlobalMid_Lock);
905 set_current_state(TASK_INTERRUPTIBLE);
906 schedule_timeout(39*HZ);
908 oplock_item = list_entry(GlobalOplock_Q.next,
909 struct oplock_q_entry, qhead);
911 cFYI(1, ("found oplock item to write out"));
912 pTcon = oplock_item->tcon;
913 inode = oplock_item->pinode;
914 netfid = oplock_item->netfid;
915 spin_unlock(&GlobalMid_Lock);
916 DeleteOplockQEntry(oplock_item);
917 /* can not grab inode sem here since it would
918 deadlock when oplock received on delete
919 since vfs_unlink holds the i_mutex across
921 /* mutex_lock(&inode->i_mutex);*/
922 if (S_ISREG(inode->i_mode)) {
924 filemap_fdatawrite(inode->i_mapping);
925 if (CIFS_I(inode)->clientCanCacheRead
927 waitrc = filemap_fdatawait(inode->i_mapping);
928 invalidate_remote_inode(inode);
934 /* mutex_unlock(&inode->i_mutex);*/
936 CIFS_I(inode)->write_behind_rc = rc;
937 cFYI(1, ("Oplock flush inode %p rc %d",
940 /* releasing stale oplock after recent reconnect
941 of smb session using a now incorrect file
942 handle is not a data integrity issue but do
943 not bother sending an oplock release if session
944 to server still is disconnected since oplock
945 already released by the server in that case */
946 if (pTcon->tidStatus != CifsNeedReconnect) {
947 rc = CIFSSMBLock(0, pTcon, netfid,
948 0 /* len */ , 0 /* offset */, 0,
949 0, LOCKING_ANDX_OPLOCK_RELEASE,
951 cFYI(1, ("Oplock release rc = %d", rc));
954 spin_unlock(&GlobalMid_Lock);
955 set_current_state(TASK_INTERRUPTIBLE);
956 schedule_timeout(1); /* yield in case q were corrupt */
958 } while (!kthread_should_stop());
963 static int cifs_dnotify_thread(void *dummyarg)
965 struct list_head *tmp;
966 struct cifsSesInfo *ses;
971 set_current_state(TASK_INTERRUPTIBLE);
972 schedule_timeout(15*HZ);
973 read_lock(&GlobalSMBSeslock);
974 /* check if any stuck requests that need
975 to be woken up and wakeq so the
976 thread can wake up and error out */
977 list_for_each(tmp, &GlobalSMBSessionList) {
978 ses = list_entry(tmp, struct cifsSesInfo,
980 if (ses && ses->server &&
981 atomic_read(&ses->server->inFlight))
982 wake_up_all(&ses->server->response_q);
984 read_unlock(&GlobalSMBSeslock);
985 } while (!kthread_should_stop());
994 #ifdef CONFIG_PROC_FS
997 /* INIT_LIST_HEAD(&GlobalServerList);*/ /* BB not implemented yet */
998 INIT_LIST_HEAD(&GlobalSMBSessionList);
999 INIT_LIST_HEAD(&GlobalTreeConnectionList);
1000 INIT_LIST_HEAD(&GlobalOplock_Q);
1001 #ifdef CONFIG_CIFS_EXPERIMENTAL
1002 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1003 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1006 * Initialize Global counters
1008 atomic_set(&sesInfoAllocCount, 0);
1009 atomic_set(&tconInfoAllocCount, 0);
1010 atomic_set(&tcpSesAllocCount, 0);
1011 atomic_set(&tcpSesReconnectCount, 0);
1012 atomic_set(&tconInfoReconnectCount, 0);
1014 atomic_set(&bufAllocCount, 0);
1015 atomic_set(&smBufAllocCount, 0);
1016 #ifdef CONFIG_CIFS_STATS2
1017 atomic_set(&totBufAllocCount, 0);
1018 atomic_set(&totSmBufAllocCount, 0);
1019 #endif /* CONFIG_CIFS_STATS2 */
1021 atomic_set(&midCount, 0);
1022 GlobalCurrentXid = 0;
1023 GlobalTotalActiveXid = 0;
1024 GlobalMaxActiveXid = 0;
1025 memset(Local_System_Name, 0, 15);
1026 rwlock_init(&GlobalSMBSeslock);
1027 spin_lock_init(&GlobalMid_Lock);
1029 if (cifs_max_pending < 2) {
1030 cifs_max_pending = 2;
1031 cFYI(1, ("cifs_max_pending set to min of 2"));
1032 } else if (cifs_max_pending > 256) {
1033 cifs_max_pending = 256;
1034 cFYI(1, ("cifs_max_pending set to max of 256"));
1037 rc = cifs_init_inodecache();
1039 goto out_clean_proc;
1041 rc = cifs_init_mids();
1043 goto out_destroy_inodecache;
1045 rc = cifs_init_request_bufs();
1047 goto out_destroy_mids;
1049 rc = register_filesystem(&cifs_fs_type);
1051 goto out_destroy_request_bufs;
1052 #ifdef CONFIG_CIFS_UPCALL
1053 rc = register_key_type(&cifs_spnego_key_type);
1055 goto out_unregister_filesystem;
1057 #ifdef CONFIG_CIFS_DFS_UPCALL
1058 rc = register_key_type(&key_type_dns_resolver);
1060 goto out_unregister_key_type;
1062 oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
1063 if (IS_ERR(oplockThread)) {
1064 rc = PTR_ERR(oplockThread);
1065 cERROR(1, ("error %d create oplock thread", rc));
1066 goto out_unregister_dfs_key_type;
1069 dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
1070 if (IS_ERR(dnotifyThread)) {
1071 rc = PTR_ERR(dnotifyThread);
1072 cERROR(1, ("error %d create dnotify thread", rc));
1073 goto out_stop_oplock_thread;
1078 out_stop_oplock_thread:
1079 kthread_stop(oplockThread);
1080 out_unregister_dfs_key_type:
1081 #ifdef CONFIG_CIFS_DFS_UPCALL
1082 unregister_key_type(&key_type_dns_resolver);
1083 out_unregister_key_type:
1085 #ifdef CONFIG_CIFS_UPCALL
1086 unregister_key_type(&cifs_spnego_key_type);
1087 out_unregister_filesystem:
1089 unregister_filesystem(&cifs_fs_type);
1090 out_destroy_request_bufs:
1091 cifs_destroy_request_bufs();
1093 cifs_destroy_mids();
1094 out_destroy_inodecache:
1095 cifs_destroy_inodecache();
1097 #ifdef CONFIG_PROC_FS
1106 cFYI(0, ("exit_cifs"));
1107 #ifdef CONFIG_PROC_FS
1110 #ifdef CONFIG_CIFS_DFS_UPCALL
1111 unregister_key_type(&key_type_dns_resolver);
1113 #ifdef CONFIG_CIFS_UPCALL
1114 unregister_key_type(&cifs_spnego_key_type);
1116 unregister_filesystem(&cifs_fs_type);
1117 cifs_destroy_inodecache();
1118 cifs_destroy_mids();
1119 cifs_destroy_request_bufs();
1120 kthread_stop(oplockThread);
1121 kthread_stop(dnotifyThread);
1124 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1125 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1127 ("VFS to access servers complying with the SNIA CIFS Specification "
1128 "e.g. Samba and Windows");
1129 MODULE_VERSION(CIFS_VERSION);
1130 module_init(init_cifs)
1131 module_exit(exit_cifs)