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>
38 #include <linux/smp_lock.h>
41 #define DECLARE_GLOBALS_HERE
43 #include "cifsproto.h"
44 #include "cifs_debug.h"
45 #include "cifs_fs_sb.h"
47 #include <linux/key-type.h>
48 #include "dns_resolve.h"
49 #include "cifs_spnego.h"
50 #define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
52 #ifdef CONFIG_CIFS_QUOTA
53 static const struct quotactl_ops cifs_quotactl_ops;
59 unsigned int oplockEnabled = 1;
60 unsigned int experimEnabled = 0;
61 unsigned int linuxExtEnabled = 1;
62 unsigned int lookupCacheEnabled = 1;
63 unsigned int multiuser_mount = 0;
64 unsigned int global_secflags = CIFSSEC_DEF;
65 /* unsigned int ntlmv2_support = 0; */
66 unsigned int sign_CIFS_PDUs = 1;
67 static const struct super_operations cifs_super_ops;
68 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
69 module_param(CIFSMaxBufSize, int, 0);
70 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
71 "Default: 16384 Range: 8192 to 130048");
72 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
73 module_param(cifs_min_rcv, int, 0);
74 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
76 unsigned int cifs_min_small = 30;
77 module_param(cifs_min_small, int, 0);
78 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
80 unsigned int cifs_max_pending = CIFS_MAX_REQ;
81 module_param(cifs_max_pending, int, 0);
82 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
83 "Default: 50 Range: 2 to 256");
85 extern mempool_t *cifs_sm_req_poolp;
86 extern mempool_t *cifs_req_poolp;
87 extern mempool_t *cifs_mid_poolp;
90 cifs_read_super(struct super_block *sb, void *data,
91 const char *devname, int silent)
94 struct cifs_sb_info *cifs_sb;
97 /* BB should we make this contingent on mount parm? */
98 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
99 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
100 cifs_sb = CIFS_SB(sb);
104 #ifdef CONFIG_CIFS_DFS_UPCALL
105 /* copy mount params to sb for use in submounts */
106 /* BB: should we move this after the mount so we
107 * do not have to do the copy on failed mounts?
108 * BB: May be it is better to do simple copy before
109 * complex operation (mount), and in case of fail
110 * just exit instead of doing mount and attempting
111 * undo it if this copy fails?*/
113 int len = strlen(data);
114 cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
115 if (cifs_sb->mountdata == NULL) {
116 kfree(sb->s_fs_info);
117 sb->s_fs_info = NULL;
120 strncpy(cifs_sb->mountdata, data, len + 1);
121 cifs_sb->mountdata[len] = '\0';
125 rc = cifs_mount(sb, cifs_sb, data, devname);
129 cERROR(1, "cifs_mount failed w/return code = %d", rc);
130 goto out_mount_failed;
133 sb->s_magic = CIFS_MAGIC_NUMBER;
134 sb->s_op = &cifs_super_ops;
135 /* if (cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
137 cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
138 #ifdef CONFIG_CIFS_QUOTA
139 sb->s_qcop = &cifs_quotactl_ops;
141 sb->s_blocksize = CIFS_MAX_MSGSIZE;
142 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
143 inode = cifs_root_iget(sb, ROOT_I);
151 sb->s_root = d_alloc_root(inode);
158 #ifdef CONFIG_CIFS_EXPERIMENTAL
159 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
160 cFYI(1, "export ops supported");
161 sb->s_export_op = &cifs_export_ops;
163 #endif /* EXPERIMENTAL */
168 cERROR(1, "cifs_read_super: get root inode failed");
172 cifs_umount(sb, cifs_sb);
176 #ifdef CONFIG_CIFS_DFS_UPCALL
177 if (cifs_sb->mountdata) {
178 kfree(cifs_sb->mountdata);
179 cifs_sb->mountdata = NULL;
182 unload_nls(cifs_sb->local_nls);
189 cifs_put_super(struct super_block *sb)
192 struct cifs_sb_info *cifs_sb;
194 cFYI(1, "In cifs_put_super");
195 cifs_sb = CIFS_SB(sb);
196 if (cifs_sb == NULL) {
197 cFYI(1, "Empty cifs superblock info passed to unmount");
203 rc = cifs_umount(sb, cifs_sb);
205 cERROR(1, "cifs_umount failed with return code %d", rc);
206 #ifdef CONFIG_CIFS_DFS_UPCALL
207 if (cifs_sb->mountdata) {
208 kfree(cifs_sb->mountdata);
209 cifs_sb->mountdata = NULL;
213 unload_nls(cifs_sb->local_nls);
220 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
222 struct super_block *sb = dentry->d_sb;
223 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
224 struct cifsTconInfo *tcon = cifs_sb->tcon;
225 int rc = -EOPNOTSUPP;
230 buf->f_type = CIFS_MAGIC_NUMBER;
233 * PATH_MAX may be too long - it would presumably be total path,
234 * but note that some servers (includinng Samba 3) have a shorter
237 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
239 buf->f_namelen = PATH_MAX;
240 buf->f_files = 0; /* undefined */
241 buf->f_ffree = 0; /* unlimited */
244 * We could add a second check for a QFS Unix capability bit
246 if ((tcon->ses->capabilities & CAP_UNIX) &&
247 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
248 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
251 * Only need to call the old QFSInfo if failed on newer one,
254 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
255 rc = CIFSSMBQFSInfo(xid, tcon, buf);
258 * Some old Windows servers also do not support level 103, retry with
259 * older level one if old server failed the previous call or we
260 * bypassed it because we detected that this was an older LANMAN sess
263 rc = SMBOldQFSInfo(xid, tcon, buf);
269 static int cifs_permission(struct inode *inode, int mask)
271 struct cifs_sb_info *cifs_sb;
273 cifs_sb = CIFS_SB(inode->i_sb);
275 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
276 if ((mask & MAY_EXEC) && !execute_ok(inode))
280 } else /* file mode might have been restricted at mount time
281 on the client (above and beyond ACL on servers) for
282 servers which do not support setting and viewing mode bits,
283 so allowing client to check permissions is useful */
284 return generic_permission(inode, mask, NULL);
287 static struct kmem_cache *cifs_inode_cachep;
288 static struct kmem_cache *cifs_req_cachep;
289 static struct kmem_cache *cifs_mid_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 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->delete_pending = false;
311 cifs_inode->invalid_mapping = false;
312 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
313 cifs_inode->server_eof = 0;
315 /* Can not set i_flags here - they get immediately overwritten
316 to zero by the VFS */
317 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
318 INIT_LIST_HEAD(&cifs_inode->openFileList);
319 return &cifs_inode->vfs_inode;
323 cifs_destroy_inode(struct inode *inode)
325 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
329 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
331 seq_printf(s, ",addr=");
333 switch (server->addr.sockAddr.sin_family) {
335 seq_printf(s, "%pI4", &server->addr.sockAddr.sin_addr.s_addr);
338 seq_printf(s, "%pI6",
339 &server->addr.sockAddr6.sin6_addr.s6_addr);
340 if (server->addr.sockAddr6.sin6_scope_id)
341 seq_printf(s, "%%%u",
342 server->addr.sockAddr6.sin6_scope_id);
345 seq_printf(s, "(unknown)");
350 * cifs_show_options() is for displaying mount options in /proc/mounts.
351 * Not all settable options are displayed but most of the important
355 cifs_show_options(struct seq_file *s, struct vfsmount *m)
357 struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
358 struct cifsTconInfo *tcon = cifs_sb->tcon;
360 seq_printf(s, ",unc=%s", tcon->treeName);
361 if (tcon->ses->userName)
362 seq_printf(s, ",username=%s", tcon->ses->userName);
363 if (tcon->ses->domainName)
364 seq_printf(s, ",domain=%s", tcon->ses->domainName);
366 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
367 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
368 seq_printf(s, ",forceuid");
370 seq_printf(s, ",noforceuid");
372 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
373 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
374 seq_printf(s, ",forcegid");
376 seq_printf(s, ",noforcegid");
378 cifs_show_address(s, tcon->ses->server);
381 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
382 cifs_sb->mnt_file_mode,
383 cifs_sb->mnt_dir_mode);
385 seq_printf(s, ",seal");
387 seq_printf(s, ",nocase");
389 seq_printf(s, ",hard");
390 if (cifs_sb->prepath)
391 seq_printf(s, ",prepath=%s", cifs_sb->prepath);
392 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
393 seq_printf(s, ",posixpaths");
394 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
395 seq_printf(s, ",setuids");
396 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
397 seq_printf(s, ",serverino");
398 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
399 seq_printf(s, ",directio");
400 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
401 seq_printf(s, ",nouser_xattr");
402 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
403 seq_printf(s, ",mapchars");
404 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
405 seq_printf(s, ",sfu");
406 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
407 seq_printf(s, ",nobrl");
408 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
409 seq_printf(s, ",cifsacl");
410 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
411 seq_printf(s, ",dynperm");
412 if (m->mnt_sb->s_flags & MS_POSIXACL)
413 seq_printf(s, ",acl");
415 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
416 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
421 #ifdef CONFIG_CIFS_QUOTA
422 int cifs_xquota_set(struct super_block *sb, int quota_type, qid_t qid,
423 struct fs_disk_quota *pdquota)
427 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
428 struct cifsTconInfo *pTcon;
431 pTcon = cifs_sb->tcon;
438 cFYI(1, "set type: 0x%x id: %d", quota_type, qid);
446 int cifs_xquota_get(struct super_block *sb, int quota_type, qid_t qid,
447 struct fs_disk_quota *pdquota)
451 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
452 struct cifsTconInfo *pTcon;
455 pTcon = cifs_sb->tcon;
461 cFYI(1, "set type: 0x%x id: %d", quota_type, qid);
469 int cifs_xstate_set(struct super_block *sb, unsigned int flags, int operation)
473 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
474 struct cifsTconInfo *pTcon;
477 pTcon = cifs_sb->tcon;
483 cFYI(1, "flags: 0x%x operation: 0x%x", flags, operation);
491 int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
495 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
496 struct cifsTconInfo *pTcon;
499 pTcon = cifs_sb->tcon;
505 cFYI(1, "pqstats %p", qstats);
513 static const struct quotactl_ops cifs_quotactl_ops = {
514 .set_xquota = cifs_xquota_set,
515 .get_xquota = cifs_xquota_get,
516 .set_xstate = cifs_xstate_set,
517 .get_xstate = cifs_xstate_get,
521 static void cifs_umount_begin(struct super_block *sb)
523 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
524 struct cifsTconInfo *tcon;
529 tcon = cifs_sb->tcon;
533 read_lock(&cifs_tcp_ses_lock);
534 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
535 /* we have other mounts to same share or we have
536 already tried to force umount this and woken up
537 all waiting network requests, nothing to do */
538 read_unlock(&cifs_tcp_ses_lock);
540 } else if (tcon->tc_count == 1)
541 tcon->tidStatus = CifsExiting;
542 read_unlock(&cifs_tcp_ses_lock);
544 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
545 /* cancel_notify_requests(tcon); */
546 if (tcon->ses && tcon->ses->server) {
547 cFYI(1, "wake up tasks now - umount begin not complete");
548 wake_up_all(&tcon->ses->server->request_q);
549 wake_up_all(&tcon->ses->server->response_q);
550 msleep(1); /* yield */
551 /* we have to kick the requests once more */
552 wake_up_all(&tcon->ses->server->response_q);
559 #ifdef CONFIG_CIFS_STATS2
560 static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
567 static int cifs_remount(struct super_block *sb, int *flags, char *data)
569 *flags |= MS_NODIRATIME;
573 static const struct super_operations cifs_super_ops = {
574 .put_super = cifs_put_super,
575 .statfs = cifs_statfs,
576 .alloc_inode = cifs_alloc_inode,
577 .destroy_inode = cifs_destroy_inode,
578 /* .drop_inode = generic_delete_inode,
579 .delete_inode = cifs_delete_inode, */ /* Do not need above two
580 functions unless later we add lazy close of inodes or unless the
581 kernel forgets to call us with the same number of releases (closes)
583 .show_options = cifs_show_options,
584 .umount_begin = cifs_umount_begin,
585 .remount_fs = cifs_remount,
586 #ifdef CONFIG_CIFS_STATS2
587 .show_stats = cifs_show_stats,
592 cifs_get_sb(struct file_system_type *fs_type,
593 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
596 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
598 cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
605 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
607 deactivate_locked_super(sb);
610 sb->s_flags |= MS_ACTIVE;
611 simple_set_mnt(mnt, sb);
615 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
616 unsigned long nr_segs, loff_t pos)
618 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
621 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
622 if (!CIFS_I(inode)->clientCanCacheAll)
623 filemap_fdatawrite(inode->i_mapping);
627 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
629 /* origin == SEEK_END => we must revalidate the cached file length */
630 if (origin == SEEK_END) {
633 /* some applications poll for the file length in this strange
634 way so we must seek to end on non-oplocked files by
635 setting the revalidate time to zero */
636 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
638 retval = cifs_revalidate_file(file);
640 return (loff_t)retval;
642 return generic_file_llseek_unlocked(file, offset, origin);
645 static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
647 /* note that this is called by vfs setlease with the BKL held
648 although I doubt that BKL is needed here in cifs */
649 struct inode *inode = file->f_path.dentry->d_inode;
651 if (!(S_ISREG(inode->i_mode)))
654 /* check if file is oplocked */
655 if (((arg == F_RDLCK) &&
656 (CIFS_I(inode)->clientCanCacheRead)) ||
658 (CIFS_I(inode)->clientCanCacheAll)))
659 return generic_setlease(file, arg, lease);
660 else if (CIFS_SB(inode->i_sb)->tcon->local_lease &&
661 !CIFS_I(inode)->clientCanCacheRead)
662 /* If the server claims to support oplock on this
663 file, then we still need to check oplock even
664 if the local_lease mount option is set, but there
665 are servers which do not support oplock for which
666 this mount option may be useful if the user
667 knows that the file won't be changed on the server
669 return generic_setlease(file, arg, lease);
674 struct file_system_type cifs_fs_type = {
675 .owner = THIS_MODULE,
677 .get_sb = cifs_get_sb,
678 .kill_sb = kill_anon_super,
681 const struct inode_operations cifs_dir_inode_ops = {
682 .create = cifs_create,
683 .lookup = cifs_lookup,
684 .getattr = cifs_getattr,
685 .unlink = cifs_unlink,
686 .link = cifs_hardlink,
689 .rename = cifs_rename,
690 .permission = cifs_permission,
691 /* revalidate:cifs_revalidate, */
692 .setattr = cifs_setattr,
693 .symlink = cifs_symlink,
695 #ifdef CONFIG_CIFS_XATTR
696 .setxattr = cifs_setxattr,
697 .getxattr = cifs_getxattr,
698 .listxattr = cifs_listxattr,
699 .removexattr = cifs_removexattr,
703 const struct inode_operations cifs_file_inode_ops = {
704 /* revalidate:cifs_revalidate, */
705 .setattr = cifs_setattr,
706 .getattr = cifs_getattr, /* do we need this anymore? */
707 .rename = cifs_rename,
708 .permission = cifs_permission,
709 #ifdef CONFIG_CIFS_XATTR
710 .setxattr = cifs_setxattr,
711 .getxattr = cifs_getxattr,
712 .listxattr = cifs_listxattr,
713 .removexattr = cifs_removexattr,
717 const struct inode_operations cifs_symlink_inode_ops = {
718 .readlink = generic_readlink,
719 .follow_link = cifs_follow_link,
720 .put_link = cifs_put_link,
721 .permission = cifs_permission,
722 /* BB add the following two eventually */
723 /* revalidate: cifs_revalidate,
724 setattr: cifs_notify_change, *//* BB do we need notify change */
725 #ifdef CONFIG_CIFS_XATTR
726 .setxattr = cifs_setxattr,
727 .getxattr = cifs_getxattr,
728 .listxattr = cifs_listxattr,
729 .removexattr = cifs_removexattr,
733 const struct file_operations cifs_file_ops = {
734 .read = do_sync_read,
735 .write = do_sync_write,
736 .aio_read = generic_file_aio_read,
737 .aio_write = cifs_file_aio_write,
739 .release = cifs_close,
743 .mmap = cifs_file_mmap,
744 .splice_read = generic_file_splice_read,
745 .llseek = cifs_llseek,
746 #ifdef CONFIG_CIFS_POSIX
747 .unlocked_ioctl = cifs_ioctl,
748 #endif /* CONFIG_CIFS_POSIX */
749 .setlease = cifs_setlease,
752 const struct file_operations cifs_file_direct_ops = {
753 /* no aio, no readv -
754 BB reevaluate whether they can be done with directio, no cache */
755 .read = cifs_user_read,
756 .write = cifs_user_write,
758 .release = cifs_close,
762 .mmap = cifs_file_mmap,
763 .splice_read = generic_file_splice_read,
764 #ifdef CONFIG_CIFS_POSIX
765 .unlocked_ioctl = cifs_ioctl,
766 #endif /* CONFIG_CIFS_POSIX */
767 .llseek = cifs_llseek,
768 .setlease = cifs_setlease,
770 const struct file_operations cifs_file_nobrl_ops = {
771 .read = do_sync_read,
772 .write = do_sync_write,
773 .aio_read = generic_file_aio_read,
774 .aio_write = cifs_file_aio_write,
776 .release = cifs_close,
779 .mmap = cifs_file_mmap,
780 .splice_read = generic_file_splice_read,
781 .llseek = cifs_llseek,
782 #ifdef CONFIG_CIFS_POSIX
783 .unlocked_ioctl = cifs_ioctl,
784 #endif /* CONFIG_CIFS_POSIX */
785 .setlease = cifs_setlease,
788 const struct file_operations cifs_file_direct_nobrl_ops = {
789 /* no mmap, no aio, no readv -
790 BB reevaluate whether they can be done with directio, no cache */
791 .read = cifs_user_read,
792 .write = cifs_user_write,
794 .release = cifs_close,
797 .mmap = cifs_file_mmap,
798 .splice_read = generic_file_splice_read,
799 #ifdef CONFIG_CIFS_POSIX
800 .unlocked_ioctl = cifs_ioctl,
801 #endif /* CONFIG_CIFS_POSIX */
802 .llseek = cifs_llseek,
803 .setlease = cifs_setlease,
806 const struct file_operations cifs_dir_ops = {
807 .readdir = cifs_readdir,
808 .release = cifs_closedir,
809 .read = generic_read_dir,
810 .unlocked_ioctl = cifs_ioctl,
811 .llseek = generic_file_llseek,
815 cifs_init_once(void *inode)
817 struct cifsInodeInfo *cifsi = inode;
819 inode_init_once(&cifsi->vfs_inode);
820 INIT_LIST_HEAD(&cifsi->lockList);
824 cifs_init_inodecache(void)
826 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
827 sizeof(struct cifsInodeInfo),
828 0, (SLAB_RECLAIM_ACCOUNT|
831 if (cifs_inode_cachep == NULL)
838 cifs_destroy_inodecache(void)
840 kmem_cache_destroy(cifs_inode_cachep);
844 cifs_init_request_bufs(void)
846 if (CIFSMaxBufSize < 8192) {
847 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
848 Unicode path name has to fit in any SMB/CIFS path based frames */
849 CIFSMaxBufSize = 8192;
850 } else if (CIFSMaxBufSize > 1024*127) {
851 CIFSMaxBufSize = 1024 * 127;
853 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
855 /* cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
856 cifs_req_cachep = kmem_cache_create("cifs_request",
858 MAX_CIFS_HDR_SIZE, 0,
859 SLAB_HWCACHE_ALIGN, NULL);
860 if (cifs_req_cachep == NULL)
863 if (cifs_min_rcv < 1)
865 else if (cifs_min_rcv > 64) {
867 cERROR(1, "cifs_min_rcv set to maximum (64)");
870 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
873 if (cifs_req_poolp == NULL) {
874 kmem_cache_destroy(cifs_req_cachep);
877 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
878 almost all handle based requests (but not write response, nor is it
879 sufficient for path based requests). A smaller size would have
880 been more efficient (compacting multiple slab items on one 4k page)
881 for the case in which debug was on, but this larger size allows
882 more SMBs to use small buffer alloc and is still much more
883 efficient to alloc 1 per page off the slab compared to 17K (5page)
884 alloc of large cifs buffers even when page debugging is on */
885 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
886 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
888 if (cifs_sm_req_cachep == NULL) {
889 mempool_destroy(cifs_req_poolp);
890 kmem_cache_destroy(cifs_req_cachep);
894 if (cifs_min_small < 2)
896 else if (cifs_min_small > 256) {
897 cifs_min_small = 256;
898 cFYI(1, "cifs_min_small set to maximum (256)");
901 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
904 if (cifs_sm_req_poolp == NULL) {
905 mempool_destroy(cifs_req_poolp);
906 kmem_cache_destroy(cifs_req_cachep);
907 kmem_cache_destroy(cifs_sm_req_cachep);
915 cifs_destroy_request_bufs(void)
917 mempool_destroy(cifs_req_poolp);
918 kmem_cache_destroy(cifs_req_cachep);
919 mempool_destroy(cifs_sm_req_poolp);
920 kmem_cache_destroy(cifs_sm_req_cachep);
926 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
927 sizeof(struct mid_q_entry), 0,
928 SLAB_HWCACHE_ALIGN, NULL);
929 if (cifs_mid_cachep == NULL)
932 /* 3 is a reasonable minimum number of simultaneous operations */
933 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
934 if (cifs_mid_poolp == NULL) {
935 kmem_cache_destroy(cifs_mid_cachep);
943 cifs_destroy_mids(void)
945 mempool_destroy(cifs_mid_poolp);
946 kmem_cache_destroy(cifs_mid_cachep);
954 INIT_LIST_HEAD(&cifs_tcp_ses_list);
955 #ifdef CONFIG_CIFS_EXPERIMENTAL
956 INIT_LIST_HEAD(&GlobalDnotifyReqList);
957 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
960 * Initialize Global counters
962 atomic_set(&sesInfoAllocCount, 0);
963 atomic_set(&tconInfoAllocCount, 0);
964 atomic_set(&tcpSesAllocCount, 0);
965 atomic_set(&tcpSesReconnectCount, 0);
966 atomic_set(&tconInfoReconnectCount, 0);
968 atomic_set(&bufAllocCount, 0);
969 atomic_set(&smBufAllocCount, 0);
970 #ifdef CONFIG_CIFS_STATS2
971 atomic_set(&totBufAllocCount, 0);
972 atomic_set(&totSmBufAllocCount, 0);
973 #endif /* CONFIG_CIFS_STATS2 */
975 atomic_set(&midCount, 0);
976 GlobalCurrentXid = 0;
977 GlobalTotalActiveXid = 0;
978 GlobalMaxActiveXid = 0;
979 memset(Local_System_Name, 0, 15);
980 rwlock_init(&GlobalSMBSeslock);
981 rwlock_init(&cifs_tcp_ses_lock);
982 spin_lock_init(&GlobalMid_Lock);
984 if (cifs_max_pending < 2) {
985 cifs_max_pending = 2;
986 cFYI(1, "cifs_max_pending set to min of 2");
987 } else if (cifs_max_pending > 256) {
988 cifs_max_pending = 256;
989 cFYI(1, "cifs_max_pending set to max of 256");
992 rc = cifs_init_inodecache();
996 rc = cifs_init_mids();
998 goto out_destroy_inodecache;
1000 rc = cifs_init_request_bufs();
1002 goto out_destroy_mids;
1004 rc = register_filesystem(&cifs_fs_type);
1006 goto out_destroy_request_bufs;
1007 #ifdef CONFIG_CIFS_UPCALL
1008 rc = register_key_type(&cifs_spnego_key_type);
1010 goto out_unregister_filesystem;
1012 #ifdef CONFIG_CIFS_DFS_UPCALL
1013 rc = register_key_type(&key_type_dns_resolver);
1015 goto out_unregister_key_type;
1017 rc = slow_work_register_user(THIS_MODULE);
1019 goto out_unregister_resolver_key;
1023 out_unregister_resolver_key:
1024 #ifdef CONFIG_CIFS_DFS_UPCALL
1025 unregister_key_type(&key_type_dns_resolver);
1026 out_unregister_key_type:
1028 #ifdef CONFIG_CIFS_UPCALL
1029 unregister_key_type(&cifs_spnego_key_type);
1030 out_unregister_filesystem:
1032 unregister_filesystem(&cifs_fs_type);
1033 out_destroy_request_bufs:
1034 cifs_destroy_request_bufs();
1036 cifs_destroy_mids();
1037 out_destroy_inodecache:
1038 cifs_destroy_inodecache();
1047 cFYI(DBG2, "exit_cifs");
1049 #ifdef CONFIG_CIFS_DFS_UPCALL
1050 cifs_dfs_release_automount_timer();
1051 unregister_key_type(&key_type_dns_resolver);
1053 #ifdef CONFIG_CIFS_UPCALL
1054 unregister_key_type(&cifs_spnego_key_type);
1056 unregister_filesystem(&cifs_fs_type);
1057 cifs_destroy_inodecache();
1058 cifs_destroy_mids();
1059 cifs_destroy_request_bufs();
1062 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1063 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1065 ("VFS to access servers complying with the SNIA CIFS Specification "
1066 "e.g. Samba and Windows");
1067 MODULE_VERSION(CIFS_VERSION);
1068 module_init(init_cifs)
1069 module_exit(exit_cifs)