4 * Copyright (C) International Business Machines Corp., 2002,2008
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 #ifdef CONFIG_CIFS_EXPERIMENTAL
70 static struct task_struct *dnotifyThread = NULL;
72 static const struct super_operations cifs_super_ops;
73 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
74 module_param(CIFSMaxBufSize, int, 0);
75 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
76 "Default: 16384 Range: 8192 to 130048");
77 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
78 module_param(cifs_min_rcv, int, 0);
79 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
81 unsigned int cifs_min_small = 30;
82 module_param(cifs_min_small, int, 0);
83 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
85 unsigned int cifs_max_pending = CIFS_MAX_REQ;
86 module_param(cifs_max_pending, int, 0);
87 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
88 "Default: 50 Range: 2 to 256");
90 extern mempool_t *cifs_sm_req_poolp;
91 extern mempool_t *cifs_req_poolp;
92 extern mempool_t *cifs_mid_poolp;
94 extern struct kmem_cache *cifs_oplock_cachep;
97 cifs_read_super(struct super_block *sb, void *data,
98 const char *devname, int silent)
101 struct cifs_sb_info *cifs_sb;
104 /* BB should we make this contingent on mount parm? */
105 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
106 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
107 cifs_sb = CIFS_SB(sb);
111 #ifdef CONFIG_CIFS_DFS_UPCALL
112 /* copy mount params to sb for use in submounts */
113 /* BB: should we move this after the mount so we
114 * do not have to do the copy on failed mounts?
115 * BB: May be it is better to do simple copy before
116 * complex operation (mount), and in case of fail
117 * just exit instead of doing mount and attempting
118 * undo it if this copy fails?*/
120 int len = strlen(data);
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';
132 rc = cifs_mount(sb, cifs_sb, data, devname);
137 ("cifs_mount failed w/return code = %d", rc));
138 goto out_mount_failed;
141 sb->s_magic = CIFS_MAGIC_NUMBER;
142 sb->s_op = &cifs_super_ops;
143 /* if (cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
145 cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
146 #ifdef CONFIG_CIFS_QUOTA
147 sb->s_qcop = &cifs_quotactl_ops;
149 sb->s_blocksize = CIFS_MAX_MSGSIZE;
150 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
151 inode = cifs_iget(sb, ROOT_I);
159 sb->s_root = d_alloc_root(inode);
166 #ifdef CONFIG_CIFS_EXPERIMENTAL
167 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
168 cFYI(1, ("export ops supported"));
169 sb->s_export_op = &cifs_export_ops;
171 #endif /* EXPERIMENTAL */
176 cERROR(1, ("cifs_read_super: get root inode failed"));
180 cifs_umount(sb, cifs_sb);
184 #ifdef CONFIG_CIFS_DFS_UPCALL
185 if (cifs_sb->mountdata) {
186 kfree(cifs_sb->mountdata);
187 cifs_sb->mountdata = NULL;
190 if (cifs_sb->local_nls)
191 unload_nls(cifs_sb->local_nls);
198 cifs_put_super(struct super_block *sb)
201 struct cifs_sb_info *cifs_sb;
203 cFYI(1, ("In cifs_put_super"));
204 cifs_sb = CIFS_SB(sb);
205 if (cifs_sb == NULL) {
206 cFYI(1, ("Empty cifs superblock info passed to unmount"));
209 rc = cifs_umount(sb, cifs_sb);
211 cERROR(1, ("cifs_umount failed with return code %d", rc));
212 #ifdef CONFIG_CIFS_DFS_UPCALL
213 if (cifs_sb->mountdata) {
214 kfree(cifs_sb->mountdata);
215 cifs_sb->mountdata = NULL;
219 unload_nls(cifs_sb->local_nls);
225 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
227 struct super_block *sb = dentry->d_sb;
228 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
229 struct cifsTconInfo *tcon = cifs_sb->tcon;
230 int rc = -EOPNOTSUPP;
235 buf->f_type = CIFS_MAGIC_NUMBER;
238 * PATH_MAX may be too long - it would presumably be total path,
239 * but note that some servers (includinng Samba 3) have a shorter
242 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
244 buf->f_namelen = PATH_MAX;
245 buf->f_files = 0; /* undefined */
246 buf->f_ffree = 0; /* unlimited */
249 * We could add a second check for a QFS Unix capability bit
251 if ((tcon->ses->capabilities & CAP_UNIX) &&
252 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
253 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
256 * Only need to call the old QFSInfo if failed on newer one,
259 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
260 rc = CIFSSMBQFSInfo(xid, tcon, buf);
263 * Some old Windows servers also do not support level 103, retry with
264 * older level one if old server failed the previous call or we
265 * bypassed it because we detected that this was an older LANMAN sess
268 rc = SMBOldQFSInfo(xid, tcon, buf);
274 static int cifs_permission(struct inode *inode, int mask)
276 struct cifs_sb_info *cifs_sb;
278 cifs_sb = CIFS_SB(inode->i_sb);
280 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
281 if ((mask & MAY_EXEC) && !execute_ok(inode))
285 } else /* file mode might have been restricted at mount time
286 on the client (above and beyond ACL on servers) for
287 servers which do not support setting and viewing mode bits,
288 so allowing client to check permissions is useful */
289 return generic_permission(inode, mask, NULL);
292 static struct kmem_cache *cifs_inode_cachep;
293 static struct kmem_cache *cifs_req_cachep;
294 static struct kmem_cache *cifs_mid_cachep;
295 struct kmem_cache *cifs_oplock_cachep;
296 static struct kmem_cache *cifs_sm_req_cachep;
297 mempool_t *cifs_sm_req_poolp;
298 mempool_t *cifs_req_poolp;
299 mempool_t *cifs_mid_poolp;
301 static struct inode *
302 cifs_alloc_inode(struct super_block *sb)
304 struct cifsInodeInfo *cifs_inode;
305 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
308 cifs_inode->cifsAttrs = 0x20; /* default */
309 atomic_set(&cifs_inode->inUse, 0);
310 cifs_inode->time = 0;
311 cifs_inode->write_behind_rc = 0;
312 /* Until the file is open and we have gotten oplock
313 info back from the server, can not assume caching of
314 file data or metadata */
315 cifs_inode->clientCanCacheRead = false;
316 cifs_inode->clientCanCacheAll = false;
317 cifs_inode->delete_pending = false;
318 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
320 /* Can not set i_flags here - they get immediately overwritten
321 to zero by the VFS */
322 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
323 INIT_LIST_HEAD(&cifs_inode->openFileList);
324 return &cifs_inode->vfs_inode;
328 cifs_destroy_inode(struct inode *inode)
330 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
334 * cifs_show_options() is for displaying mount options in /proc/mounts.
335 * Not all settable options are displayed but most of the important
339 cifs_show_options(struct seq_file *s, struct vfsmount *m)
341 struct cifs_sb_info *cifs_sb;
342 struct cifsTconInfo *tcon;
343 struct TCP_Server_Info *server;
345 cifs_sb = CIFS_SB(m->mnt_sb);
348 tcon = cifs_sb->tcon;
350 /* BB add prepath to mount options displayed */
351 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
353 if (tcon->ses->userName)
354 seq_printf(s, ",username=%s",
355 tcon->ses->userName);
356 if (tcon->ses->domainName)
357 seq_printf(s, ",domain=%s",
358 tcon->ses->domainName);
359 server = tcon->ses->server;
361 seq_printf(s, ",addr=");
362 switch (server->addr.sockAddr6.
365 seq_printf(s, NIP6_FMT,
366 NIP6(server->addr.sockAddr6.sin6_addr));
369 seq_printf(s, NIPQUAD_FMT,
370 NIPQUAD(server->addr.sockAddr.sin_addr.s_addr));
375 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) ||
377 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
378 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) ||
380 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
381 if (!tcon->unix_ext) {
382 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
383 cifs_sb->mnt_file_mode,
384 cifs_sb->mnt_dir_mode);
387 seq_printf(s, ",seal");
389 seq_printf(s, ",nocase");
391 seq_printf(s, ",hard");
393 if (cifs_sb->prepath)
394 seq_printf(s, ",prepath=%s", cifs_sb->prepath);
395 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
396 seq_printf(s, ",posixpaths");
397 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
398 seq_printf(s, ",setuids");
399 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
400 seq_printf(s, ",serverino");
401 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
402 seq_printf(s, ",directio");
403 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
404 seq_printf(s, ",nouser_xattr");
405 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
406 seq_printf(s, ",mapchars");
407 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
408 seq_printf(s, ",sfu");
409 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
410 seq_printf(s, ",nobrl");
411 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
412 seq_printf(s, ",cifsacl");
413 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
414 seq_printf(s, ",dynperm");
415 if (m->mnt_sb->s_flags & MS_POSIXACL)
416 seq_printf(s, ",acl");
418 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
419 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
424 #ifdef CONFIG_CIFS_QUOTA
425 int cifs_xquota_set(struct super_block *sb, int quota_type, qid_t qid,
426 struct fs_disk_quota *pdquota)
430 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
431 struct cifsTconInfo *pTcon;
434 pTcon = cifs_sb->tcon;
441 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
450 int cifs_xquota_get(struct super_block *sb, int quota_type, qid_t qid,
451 struct fs_disk_quota *pdquota)
455 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
456 struct cifsTconInfo *pTcon;
459 pTcon = cifs_sb->tcon;
465 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
474 int cifs_xstate_set(struct super_block *sb, unsigned int flags, int operation)
478 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
479 struct cifsTconInfo *pTcon;
482 pTcon = cifs_sb->tcon;
488 cFYI(1, ("flags: 0x%x operation: 0x%x", flags, operation));
497 int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
501 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
502 struct cifsTconInfo *pTcon;
505 pTcon = cifs_sb->tcon;
511 cFYI(1, ("pqstats %p", qstats));
520 static struct quotactl_ops cifs_quotactl_ops = {
521 .set_xquota = cifs_xquota_set,
522 .get_xquota = cifs_xquota_get,
523 .set_xstate = cifs_xstate_set,
524 .get_xstate = cifs_xstate_get,
528 static void cifs_umount_begin(struct super_block *sb)
530 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
531 struct cifsTconInfo *tcon;
536 tcon = cifs_sb->tcon;
540 read_lock(&cifs_tcp_ses_lock);
541 if (tcon->tc_count == 1)
542 tcon->tidStatus = CifsExiting;
543 read_unlock(&cifs_tcp_ses_lock);
545 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
546 /* cancel_notify_requests(tcon); */
547 if (tcon->ses && tcon->ses->server) {
548 cFYI(1, ("wake up tasks now - umount begin not complete"));
549 wake_up_all(&tcon->ses->server->request_q);
550 wake_up_all(&tcon->ses->server->response_q);
551 msleep(1); /* yield */
552 /* we have to kick the requests once more */
553 wake_up_all(&tcon->ses->server->response_q);
556 /* BB FIXME - finish add checks for tidStatus BB */
561 #ifdef CONFIG_CIFS_STATS2
562 static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
569 static int cifs_remount(struct super_block *sb, int *flags, char *data)
571 *flags |= MS_NODIRATIME;
575 static const struct super_operations cifs_super_ops = {
576 .put_super = cifs_put_super,
577 .statfs = cifs_statfs,
578 .alloc_inode = cifs_alloc_inode,
579 .destroy_inode = cifs_destroy_inode,
580 /* .drop_inode = generic_delete_inode,
581 .delete_inode = cifs_delete_inode, */ /* Do not need above two
582 functions unless later we add lazy close of inodes or unless the
583 kernel forgets to call us with the same number of releases (closes)
585 .show_options = cifs_show_options,
586 .umount_begin = cifs_umount_begin,
587 .remount_fs = cifs_remount,
588 #ifdef CONFIG_CIFS_STATS2
589 .show_stats = cifs_show_stats,
594 cifs_get_sb(struct file_system_type *fs_type,
595 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
598 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
600 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
607 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
609 up_write(&sb->s_umount);
610 deactivate_super(sb);
613 sb->s_flags |= MS_ACTIVE;
614 return simple_set_mnt(mnt, sb);
617 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
618 unsigned long nr_segs, loff_t pos)
620 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
623 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
624 if (!CIFS_I(inode)->clientCanCacheAll)
625 filemap_fdatawrite(inode->i_mapping);
629 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
631 /* origin == SEEK_END => we must revalidate the cached file length */
632 if (origin == SEEK_END) {
635 /* some applications poll for the file length in this strange
636 way so we must seek to end on non-oplocked files by
637 setting the revalidate time to zero */
638 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
640 retval = cifs_revalidate(file->f_path.dentry);
642 return (loff_t)retval;
644 return generic_file_llseek_unlocked(file, offset, origin);
647 #ifdef CONFIG_CIFS_EXPERIMENTAL
648 static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
650 /* note that this is called by vfs setlease with the BKL held
651 although I doubt that BKL is needed here in cifs */
652 struct inode *inode = file->f_path.dentry->d_inode;
654 if (!(S_ISREG(inode->i_mode)))
657 /* check if file is oplocked */
658 if (((arg == F_RDLCK) &&
659 (CIFS_I(inode)->clientCanCacheRead)) ||
661 (CIFS_I(inode)->clientCanCacheAll)))
662 return generic_setlease(file, arg, lease);
663 else if (CIFS_SB(inode->i_sb)->tcon->local_lease &&
664 !CIFS_I(inode)->clientCanCacheRead)
665 /* If the server claims to support oplock on this
666 file, then we still need to check oplock even
667 if the local_lease mount option is set, but there
668 are servers which do not support oplock for which
669 this mount option may be useful if the user
670 knows that the file won't be changed on the server
672 return generic_setlease(file, arg, lease);
678 struct file_system_type cifs_fs_type = {
679 .owner = THIS_MODULE,
681 .get_sb = cifs_get_sb,
682 .kill_sb = kill_anon_super,
685 const struct inode_operations cifs_dir_inode_ops = {
686 .create = cifs_create,
687 .lookup = cifs_lookup,
688 .getattr = cifs_getattr,
689 .unlink = cifs_unlink,
690 .link = cifs_hardlink,
693 .rename = cifs_rename,
694 .permission = cifs_permission,
695 /* revalidate:cifs_revalidate, */
696 .setattr = cifs_setattr,
697 .symlink = cifs_symlink,
699 #ifdef CONFIG_CIFS_XATTR
700 .setxattr = cifs_setxattr,
701 .getxattr = cifs_getxattr,
702 .listxattr = cifs_listxattr,
703 .removexattr = cifs_removexattr,
707 const struct inode_operations cifs_file_inode_ops = {
708 /* revalidate:cifs_revalidate, */
709 .setattr = cifs_setattr,
710 .getattr = cifs_getattr, /* do we need this anymore? */
711 .rename = cifs_rename,
712 .permission = cifs_permission,
713 #ifdef CONFIG_CIFS_XATTR
714 .setxattr = cifs_setxattr,
715 .getxattr = cifs_getxattr,
716 .listxattr = cifs_listxattr,
717 .removexattr = cifs_removexattr,
721 const struct inode_operations cifs_symlink_inode_ops = {
722 .readlink = generic_readlink,
723 .follow_link = cifs_follow_link,
724 .put_link = cifs_put_link,
725 .permission = cifs_permission,
726 /* BB add the following two eventually */
727 /* revalidate: cifs_revalidate,
728 setattr: cifs_notify_change, *//* BB do we need notify change */
729 #ifdef CONFIG_CIFS_XATTR
730 .setxattr = cifs_setxattr,
731 .getxattr = cifs_getxattr,
732 .listxattr = cifs_listxattr,
733 .removexattr = cifs_removexattr,
737 const struct file_operations cifs_file_ops = {
738 .read = do_sync_read,
739 .write = do_sync_write,
740 .aio_read = generic_file_aio_read,
741 .aio_write = cifs_file_aio_write,
743 .release = cifs_close,
747 .mmap = cifs_file_mmap,
748 .splice_read = generic_file_splice_read,
749 .llseek = cifs_llseek,
750 #ifdef CONFIG_CIFS_POSIX
751 .unlocked_ioctl = cifs_ioctl,
752 #endif /* CONFIG_CIFS_POSIX */
754 #ifdef CONFIG_CIFS_EXPERIMENTAL
755 .dir_notify = cifs_dir_notify,
756 .setlease = cifs_setlease,
757 #endif /* CONFIG_CIFS_EXPERIMENTAL */
760 const struct file_operations cifs_file_direct_ops = {
761 /* no mmap, no aio, no readv -
762 BB reevaluate whether they can be done with directio, no cache */
763 .read = cifs_user_read,
764 .write = cifs_user_write,
766 .release = cifs_close,
770 .splice_read = generic_file_splice_read,
771 #ifdef CONFIG_CIFS_POSIX
772 .unlocked_ioctl = cifs_ioctl,
773 #endif /* CONFIG_CIFS_POSIX */
774 .llseek = cifs_llseek,
775 #ifdef CONFIG_CIFS_EXPERIMENTAL
776 .dir_notify = cifs_dir_notify,
777 .setlease = cifs_setlease,
778 #endif /* CONFIG_CIFS_EXPERIMENTAL */
780 const struct file_operations cifs_file_nobrl_ops = {
781 .read = do_sync_read,
782 .write = do_sync_write,
783 .aio_read = generic_file_aio_read,
784 .aio_write = cifs_file_aio_write,
786 .release = cifs_close,
789 .mmap = cifs_file_mmap,
790 .splice_read = generic_file_splice_read,
791 .llseek = cifs_llseek,
792 #ifdef CONFIG_CIFS_POSIX
793 .unlocked_ioctl = cifs_ioctl,
794 #endif /* CONFIG_CIFS_POSIX */
796 #ifdef CONFIG_CIFS_EXPERIMENTAL
797 .dir_notify = cifs_dir_notify,
798 .setlease = cifs_setlease,
799 #endif /* CONFIG_CIFS_EXPERIMENTAL */
802 const struct file_operations cifs_file_direct_nobrl_ops = {
803 /* no mmap, no aio, no readv -
804 BB reevaluate whether they can be done with directio, no cache */
805 .read = cifs_user_read,
806 .write = cifs_user_write,
808 .release = cifs_close,
811 .splice_read = generic_file_splice_read,
812 #ifdef CONFIG_CIFS_POSIX
813 .unlocked_ioctl = cifs_ioctl,
814 #endif /* CONFIG_CIFS_POSIX */
815 .llseek = cifs_llseek,
816 #ifdef CONFIG_CIFS_EXPERIMENTAL
817 .dir_notify = cifs_dir_notify,
818 .setlease = cifs_setlease,
819 #endif /* CONFIG_CIFS_EXPERIMENTAL */
822 const struct file_operations cifs_dir_ops = {
823 .readdir = cifs_readdir,
824 .release = cifs_closedir,
825 .read = generic_read_dir,
826 #ifdef CONFIG_CIFS_EXPERIMENTAL
827 .dir_notify = cifs_dir_notify,
828 #endif /* CONFIG_CIFS_EXPERIMENTAL */
829 .unlocked_ioctl = cifs_ioctl,
830 .llseek = generic_file_llseek,
834 cifs_init_once(void *inode)
836 struct cifsInodeInfo *cifsi = inode;
838 inode_init_once(&cifsi->vfs_inode);
839 INIT_LIST_HEAD(&cifsi->lockList);
843 cifs_init_inodecache(void)
845 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
846 sizeof(struct cifsInodeInfo),
847 0, (SLAB_RECLAIM_ACCOUNT|
850 if (cifs_inode_cachep == NULL)
857 cifs_destroy_inodecache(void)
859 kmem_cache_destroy(cifs_inode_cachep);
863 cifs_init_request_bufs(void)
865 if (CIFSMaxBufSize < 8192) {
866 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
867 Unicode path name has to fit in any SMB/CIFS path based frames */
868 CIFSMaxBufSize = 8192;
869 } else if (CIFSMaxBufSize > 1024*127) {
870 CIFSMaxBufSize = 1024 * 127;
872 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
874 /* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
875 cifs_req_cachep = kmem_cache_create("cifs_request",
877 MAX_CIFS_HDR_SIZE, 0,
878 SLAB_HWCACHE_ALIGN, NULL);
879 if (cifs_req_cachep == NULL)
882 if (cifs_min_rcv < 1)
884 else if (cifs_min_rcv > 64) {
886 cERROR(1, ("cifs_min_rcv set to maximum (64)"));
889 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
892 if (cifs_req_poolp == NULL) {
893 kmem_cache_destroy(cifs_req_cachep);
896 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
897 almost all handle based requests (but not write response, nor is it
898 sufficient for path based requests). A smaller size would have
899 been more efficient (compacting multiple slab items on one 4k page)
900 for the case in which debug was on, but this larger size allows
901 more SMBs to use small buffer alloc and is still much more
902 efficient to alloc 1 per page off the slab compared to 17K (5page)
903 alloc of large cifs buffers even when page debugging is on */
904 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
905 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
907 if (cifs_sm_req_cachep == NULL) {
908 mempool_destroy(cifs_req_poolp);
909 kmem_cache_destroy(cifs_req_cachep);
913 if (cifs_min_small < 2)
915 else if (cifs_min_small > 256) {
916 cifs_min_small = 256;
917 cFYI(1, ("cifs_min_small set to maximum (256)"));
920 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
923 if (cifs_sm_req_poolp == NULL) {
924 mempool_destroy(cifs_req_poolp);
925 kmem_cache_destroy(cifs_req_cachep);
926 kmem_cache_destroy(cifs_sm_req_cachep);
934 cifs_destroy_request_bufs(void)
936 mempool_destroy(cifs_req_poolp);
937 kmem_cache_destroy(cifs_req_cachep);
938 mempool_destroy(cifs_sm_req_poolp);
939 kmem_cache_destroy(cifs_sm_req_cachep);
945 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
946 sizeof(struct mid_q_entry), 0,
947 SLAB_HWCACHE_ALIGN, NULL);
948 if (cifs_mid_cachep == NULL)
951 /* 3 is a reasonable minimum number of simultaneous operations */
952 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
953 if (cifs_mid_poolp == NULL) {
954 kmem_cache_destroy(cifs_mid_cachep);
958 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
959 sizeof(struct oplock_q_entry), 0,
960 SLAB_HWCACHE_ALIGN, NULL);
961 if (cifs_oplock_cachep == NULL) {
962 mempool_destroy(cifs_mid_poolp);
963 kmem_cache_destroy(cifs_mid_cachep);
971 cifs_destroy_mids(void)
973 mempool_destroy(cifs_mid_poolp);
974 kmem_cache_destroy(cifs_mid_cachep);
975 kmem_cache_destroy(cifs_oplock_cachep);
978 static int cifs_oplock_thread(void *dummyarg)
980 struct oplock_q_entry *oplock_item;
981 struct cifsTconInfo *pTcon;
991 spin_lock(&GlobalMid_Lock);
992 if (list_empty(&GlobalOplock_Q)) {
993 spin_unlock(&GlobalMid_Lock);
994 set_current_state(TASK_INTERRUPTIBLE);
995 schedule_timeout(39*HZ);
997 oplock_item = list_entry(GlobalOplock_Q.next,
998 struct oplock_q_entry, qhead);
999 cFYI(1, ("found oplock item to write out"));
1000 pTcon = oplock_item->tcon;
1001 inode = oplock_item->pinode;
1002 netfid = oplock_item->netfid;
1003 spin_unlock(&GlobalMid_Lock);
1004 DeleteOplockQEntry(oplock_item);
1005 /* can not grab inode sem here since it would
1006 deadlock when oplock received on delete
1007 since vfs_unlink holds the i_mutex across
1009 /* mutex_lock(&inode->i_mutex);*/
1010 if (S_ISREG(inode->i_mode)) {
1011 #ifdef CONFIG_CIFS_EXPERIMENTAL
1012 if (CIFS_I(inode)->clientCanCacheAll == 0)
1013 break_lease(inode, FMODE_READ);
1014 else if (CIFS_I(inode)->clientCanCacheRead == 0)
1015 break_lease(inode, FMODE_WRITE);
1017 rc = filemap_fdatawrite(inode->i_mapping);
1018 if (CIFS_I(inode)->clientCanCacheRead == 0) {
1019 waitrc = filemap_fdatawait(
1021 invalidate_remote_inode(inode);
1027 /* mutex_unlock(&inode->i_mutex);*/
1029 CIFS_I(inode)->write_behind_rc = rc;
1030 cFYI(1, ("Oplock flush inode %p rc %d",
1033 /* releasing stale oplock after recent reconnect
1034 of smb session using a now incorrect file
1035 handle is not a data integrity issue but do
1036 not bother sending an oplock release if session
1037 to server still is disconnected since oplock
1038 already released by the server in that case */
1039 if (!pTcon->need_reconnect) {
1040 rc = CIFSSMBLock(0, pTcon, netfid,
1041 0 /* len */ , 0 /* offset */, 0,
1042 0, LOCKING_ANDX_OPLOCK_RELEASE,
1043 false /* wait flag */);
1044 cFYI(1, ("Oplock release rc = %d", rc));
1046 set_current_state(TASK_INTERRUPTIBLE);
1047 schedule_timeout(1); /* yield in case q were corrupt */
1049 } while (!kthread_should_stop());
1054 #ifdef CONFIG_CIFS_EXPERIMENTAL
1055 static int cifs_dnotify_thread(void *dummyarg)
1057 struct list_head *tmp;
1058 struct TCP_Server_Info *server;
1061 if (try_to_freeze())
1063 set_current_state(TASK_INTERRUPTIBLE);
1064 schedule_timeout(15*HZ);
1065 /* check if any stuck requests that need
1066 to be woken up and wakeq so the
1067 thread can wake up and error out */
1068 read_lock(&cifs_tcp_ses_lock);
1069 list_for_each(tmp, &cifs_tcp_ses_list) {
1070 server = list_entry(tmp, struct TCP_Server_Info,
1072 if (atomic_read(&server->inFlight))
1073 wake_up_all(&server->response_q);
1075 read_unlock(&cifs_tcp_ses_lock);
1076 } while (!kthread_should_stop());
1087 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1088 INIT_LIST_HEAD(&GlobalOplock_Q);
1089 #ifdef CONFIG_CIFS_EXPERIMENTAL
1090 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1091 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1094 * Initialize Global counters
1096 atomic_set(&sesInfoAllocCount, 0);
1097 atomic_set(&tconInfoAllocCount, 0);
1098 atomic_set(&tcpSesAllocCount, 0);
1099 atomic_set(&tcpSesReconnectCount, 0);
1100 atomic_set(&tconInfoReconnectCount, 0);
1102 atomic_set(&bufAllocCount, 0);
1103 atomic_set(&smBufAllocCount, 0);
1104 #ifdef CONFIG_CIFS_STATS2
1105 atomic_set(&totBufAllocCount, 0);
1106 atomic_set(&totSmBufAllocCount, 0);
1107 #endif /* CONFIG_CIFS_STATS2 */
1109 atomic_set(&midCount, 0);
1110 GlobalCurrentXid = 0;
1111 GlobalTotalActiveXid = 0;
1112 GlobalMaxActiveXid = 0;
1113 memset(Local_System_Name, 0, 15);
1114 rwlock_init(&GlobalSMBSeslock);
1115 rwlock_init(&cifs_tcp_ses_lock);
1116 spin_lock_init(&GlobalMid_Lock);
1118 if (cifs_max_pending < 2) {
1119 cifs_max_pending = 2;
1120 cFYI(1, ("cifs_max_pending set to min of 2"));
1121 } else if (cifs_max_pending > 256) {
1122 cifs_max_pending = 256;
1123 cFYI(1, ("cifs_max_pending set to max of 256"));
1126 rc = cifs_init_inodecache();
1128 goto out_clean_proc;
1130 rc = cifs_init_mids();
1132 goto out_destroy_inodecache;
1134 rc = cifs_init_request_bufs();
1136 goto out_destroy_mids;
1138 rc = register_filesystem(&cifs_fs_type);
1140 goto out_destroy_request_bufs;
1141 #ifdef CONFIG_CIFS_UPCALL
1142 rc = register_key_type(&cifs_spnego_key_type);
1144 goto out_unregister_filesystem;
1146 #ifdef CONFIG_CIFS_DFS_UPCALL
1147 rc = register_key_type(&key_type_dns_resolver);
1149 goto out_unregister_key_type;
1151 oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
1152 if (IS_ERR(oplockThread)) {
1153 rc = PTR_ERR(oplockThread);
1154 cERROR(1, ("error %d create oplock thread", rc));
1155 goto out_unregister_dfs_key_type;
1158 #ifdef CONFIG_CIFS_EXPERIMENTAL
1159 dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
1160 if (IS_ERR(dnotifyThread)) {
1161 rc = PTR_ERR(dnotifyThread);
1162 cERROR(1, ("error %d create dnotify thread", rc));
1163 goto out_stop_oplock_thread;
1169 #ifdef CONFIG_CIFS_EXPERIMENTAL
1170 out_stop_oplock_thread:
1172 kthread_stop(oplockThread);
1173 out_unregister_dfs_key_type:
1174 #ifdef CONFIG_CIFS_DFS_UPCALL
1175 unregister_key_type(&key_type_dns_resolver);
1176 out_unregister_key_type:
1178 #ifdef CONFIG_CIFS_UPCALL
1179 unregister_key_type(&cifs_spnego_key_type);
1180 out_unregister_filesystem:
1182 unregister_filesystem(&cifs_fs_type);
1183 out_destroy_request_bufs:
1184 cifs_destroy_request_bufs();
1186 cifs_destroy_mids();
1187 out_destroy_inodecache:
1188 cifs_destroy_inodecache();
1197 cFYI(DBG2, ("exit_cifs"));
1199 #ifdef CONFIG_CIFS_DFS_UPCALL
1200 cifs_dfs_release_automount_timer();
1201 unregister_key_type(&key_type_dns_resolver);
1203 #ifdef CONFIG_CIFS_UPCALL
1204 unregister_key_type(&cifs_spnego_key_type);
1206 unregister_filesystem(&cifs_fs_type);
1207 cifs_destroy_inodecache();
1208 cifs_destroy_mids();
1209 cifs_destroy_request_bufs();
1210 #ifdef CONFIG_CIFS_EXPERIMENTAL
1211 kthread_stop(dnotifyThread);
1213 kthread_stop(oplockThread);
1216 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1217 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1219 ("VFS to access servers complying with the SNIA CIFS Specification "
1220 "e.g. Samba and Windows");
1221 MODULE_VERSION(CIFS_VERSION);
1222 module_init(init_cifs)
1223 module_exit(exit_cifs)