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/namei.h>
39 #include <linux/random.h>
43 #define DECLARE_GLOBALS_HERE
45 #include "cifsproto.h"
46 #include "cifs_debug.h"
47 #include "cifs_fs_sb.h"
49 #include <linux/key-type.h>
50 #include "cifs_spnego.h"
52 #ifdef CONFIG_CIFS_SMB2
58 bool enable_oplocks = true;
59 unsigned int linuxExtEnabled = 1;
60 unsigned int lookupCacheEnabled = 1;
61 unsigned int global_secflags = CIFSSEC_DEF;
62 /* unsigned int ntlmv2_support = 0; */
63 unsigned int sign_CIFS_PDUs = 1;
64 static const struct super_operations cifs_super_ops;
65 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
66 module_param(CIFSMaxBufSize, uint, 0);
67 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
68 "Default: 16384 Range: 8192 to 130048");
69 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
70 module_param(cifs_min_rcv, uint, 0);
71 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
73 unsigned int cifs_min_small = 30;
74 module_param(cifs_min_small, uint, 0);
75 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
77 unsigned int cifs_max_pending = CIFS_MAX_REQ;
78 module_param(cifs_max_pending, uint, 0444);
79 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
80 "Default: 32767 Range: 2 to 32767.");
81 module_param(enable_oplocks, bool, 0644);
82 MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
84 extern mempool_t *cifs_sm_req_poolp;
85 extern mempool_t *cifs_req_poolp;
86 extern mempool_t *cifs_mid_poolp;
88 struct workqueue_struct *cifsiod_wq;
90 #ifdef CONFIG_CIFS_SMB2
91 __u8 cifs_client_guid[SMB2_CLIENT_GUID_SIZE];
95 * Bumps refcount for cifs super block.
96 * Note that it should be only called if a referece to VFS super block is
97 * already held, e.g. in open-type syscalls context. Otherwise it can race with
98 * atomic_dec_and_test in deactivate_locked_super.
101 cifs_sb_active(struct super_block *sb)
103 struct cifs_sb_info *server = CIFS_SB(sb);
105 if (atomic_inc_return(&server->active) == 1)
106 atomic_inc(&sb->s_active);
110 cifs_sb_deactive(struct super_block *sb)
112 struct cifs_sb_info *server = CIFS_SB(sb);
114 if (atomic_dec_and_test(&server->active))
115 deactivate_super(sb);
119 cifs_read_super(struct super_block *sb)
122 struct cifs_sb_info *cifs_sb;
125 cifs_sb = CIFS_SB(sb);
127 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
128 sb->s_flags |= MS_POSIXACL;
130 if (cifs_sb_master_tcon(cifs_sb)->ses->capabilities & CAP_LARGE_FILES)
131 sb->s_maxbytes = MAX_LFS_FILESIZE;
133 sb->s_maxbytes = MAX_NON_LFS;
135 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
136 sb->s_time_gran = 100;
138 sb->s_magic = CIFS_MAGIC_NUMBER;
139 sb->s_op = &cifs_super_ops;
140 sb->s_bdi = &cifs_sb->bdi;
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);
150 if (cifs_sb_master_tcon(cifs_sb)->nocase)
151 sb->s_d_op = &cifs_ci_dentry_ops;
153 sb->s_d_op = &cifs_dentry_ops;
155 sb->s_root = d_make_root(inode);
161 #ifdef CONFIG_CIFS_NFSD_EXPORT
162 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
163 cifs_dbg(FYI, "export ops supported\n");
164 sb->s_export_op = &cifs_export_ops;
166 #endif /* CONFIG_CIFS_NFSD_EXPORT */
171 cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
175 static void cifs_kill_sb(struct super_block *sb)
177 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
179 cifs_umount(cifs_sb);
183 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
185 struct super_block *sb = dentry->d_sb;
186 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
187 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
188 struct TCP_Server_Info *server = tcon->ses->server;
195 * PATH_MAX may be too long - it would presumably be total path,
196 * but note that some servers (includinng Samba 3) have a shorter
199 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
201 buf->f_namelen = PATH_MAX;
202 buf->f_files = 0; /* undefined */
203 buf->f_ffree = 0; /* unlimited */
205 if (server->ops->queryfs)
206 rc = server->ops->queryfs(xid, tcon, buf);
212 static int cifs_permission(struct inode *inode, int mask)
214 struct cifs_sb_info *cifs_sb;
216 cifs_sb = CIFS_SB(inode->i_sb);
218 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
219 if ((mask & MAY_EXEC) && !execute_ok(inode))
223 } else /* file mode might have been restricted at mount time
224 on the client (above and beyond ACL on servers) for
225 servers which do not support setting and viewing mode bits,
226 so allowing client to check permissions is useful */
227 return generic_permission(inode, mask);
230 static struct kmem_cache *cifs_inode_cachep;
231 static struct kmem_cache *cifs_req_cachep;
232 static struct kmem_cache *cifs_mid_cachep;
233 static struct kmem_cache *cifs_sm_req_cachep;
234 mempool_t *cifs_sm_req_poolp;
235 mempool_t *cifs_req_poolp;
236 mempool_t *cifs_mid_poolp;
238 static struct inode *
239 cifs_alloc_inode(struct super_block *sb)
241 struct cifsInodeInfo *cifs_inode;
242 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
245 cifs_inode->cifsAttrs = 0x20; /* default */
246 cifs_inode->time = 0;
248 * Until the file is open and we have gotten oplock info back from the
249 * server, can not assume caching of file data or metadata.
251 cifs_set_oplock_level(cifs_inode, 0);
252 cifs_inode->delete_pending = false;
253 cifs_inode->invalid_mapping = false;
254 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
255 cifs_inode->server_eof = 0;
256 cifs_inode->uniqueid = 0;
257 cifs_inode->createtime = 0;
258 cifs_inode->epoch = 0;
259 #ifdef CONFIG_CIFS_SMB2
260 get_random_bytes(cifs_inode->lease_key, SMB2_LEASE_KEY_SIZE);
263 * Can not set i_flags here - they get immediately overwritten to zero
266 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
267 INIT_LIST_HEAD(&cifs_inode->openFileList);
268 INIT_LIST_HEAD(&cifs_inode->llist);
269 return &cifs_inode->vfs_inode;
272 static void cifs_i_callback(struct rcu_head *head)
274 struct inode *inode = container_of(head, struct inode, i_rcu);
275 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
279 cifs_destroy_inode(struct inode *inode)
281 call_rcu(&inode->i_rcu, cifs_i_callback);
285 cifs_evict_inode(struct inode *inode)
287 truncate_inode_pages(&inode->i_data, 0);
289 cifs_fscache_release_inode_cookie(inode);
293 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
295 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
296 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
298 seq_printf(s, ",addr=");
300 switch (server->dstaddr.ss_family) {
302 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
305 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
306 if (sa6->sin6_scope_id)
307 seq_printf(s, "%%%u", sa6->sin6_scope_id);
310 seq_printf(s, "(unknown)");
315 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
317 if (ses->sectype == Unspecified)
320 seq_printf(s, ",sec=");
322 switch (ses->sectype) {
324 seq_printf(s, "lanman");
327 seq_printf(s, "ntlmv2");
330 seq_printf(s, "ntlm");
333 seq_printf(s, "krb5");
336 seq_printf(s, "ntlmssp");
339 /* shouldn't ever happen */
340 seq_printf(s, "unknown");
349 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
351 seq_printf(s, ",cache=");
353 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
354 seq_printf(s, "strict");
355 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
356 seq_printf(s, "none");
358 seq_printf(s, "loose");
362 cifs_show_nls(struct seq_file *s, struct nls_table *cur)
364 struct nls_table *def;
366 /* Display iocharset= option if it's not default charset */
367 def = load_nls_default();
369 seq_printf(s, ",iocharset=%s", cur->charset);
374 * cifs_show_options() is for displaying mount options in /proc/mounts.
375 * Not all settable options are displayed but most of the important
379 cifs_show_options(struct seq_file *s, struct dentry *root)
381 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
382 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
383 struct sockaddr *srcaddr;
384 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
386 seq_printf(s, ",vers=%s", tcon->ses->server->vals->version_string);
387 cifs_show_security(s, tcon->ses);
388 cifs_show_cache_flavor(s, cifs_sb);
390 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
391 seq_printf(s, ",multiuser");
392 else if (tcon->ses->user_name)
393 seq_printf(s, ",username=%s", tcon->ses->user_name);
395 if (tcon->ses->domainName)
396 seq_printf(s, ",domain=%s", tcon->ses->domainName);
398 if (srcaddr->sa_family != AF_UNSPEC) {
399 struct sockaddr_in *saddr4;
400 struct sockaddr_in6 *saddr6;
401 saddr4 = (struct sockaddr_in *)srcaddr;
402 saddr6 = (struct sockaddr_in6 *)srcaddr;
403 if (srcaddr->sa_family == AF_INET6)
404 seq_printf(s, ",srcaddr=%pI6c",
406 else if (srcaddr->sa_family == AF_INET)
407 seq_printf(s, ",srcaddr=%pI4",
408 &saddr4->sin_addr.s_addr);
410 seq_printf(s, ",srcaddr=BAD-AF:%i",
411 (int)(srcaddr->sa_family));
414 seq_printf(s, ",uid=%u",
415 from_kuid_munged(&init_user_ns, cifs_sb->mnt_uid));
416 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
417 seq_printf(s, ",forceuid");
419 seq_printf(s, ",noforceuid");
421 seq_printf(s, ",gid=%u",
422 from_kgid_munged(&init_user_ns, cifs_sb->mnt_gid));
423 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
424 seq_printf(s, ",forcegid");
426 seq_printf(s, ",noforcegid");
428 cifs_show_address(s, tcon->ses->server);
431 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
432 cifs_sb->mnt_file_mode,
433 cifs_sb->mnt_dir_mode);
435 cifs_show_nls(s, cifs_sb->local_nls);
438 seq_printf(s, ",seal");
440 seq_printf(s, ",nocase");
442 seq_printf(s, ",hard");
444 seq_printf(s, ",unix");
446 seq_printf(s, ",nounix");
447 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
448 seq_printf(s, ",posixpaths");
449 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
450 seq_printf(s, ",setuids");
451 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
452 seq_printf(s, ",serverino");
453 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
454 seq_printf(s, ",rwpidforward");
455 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
456 seq_printf(s, ",forcemand");
457 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
458 seq_printf(s, ",nouser_xattr");
459 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
460 seq_printf(s, ",mapchars");
461 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
462 seq_printf(s, ",sfu");
463 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
464 seq_printf(s, ",nobrl");
465 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
466 seq_printf(s, ",cifsacl");
467 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
468 seq_printf(s, ",dynperm");
469 if (root->d_sb->s_flags & MS_POSIXACL)
470 seq_printf(s, ",acl");
471 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
472 seq_printf(s, ",mfsymlinks");
473 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
474 seq_printf(s, ",fsc");
475 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
476 seq_printf(s, ",nostrictsync");
477 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
478 seq_printf(s, ",noperm");
479 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
480 seq_printf(s, ",backupuid=%u",
481 from_kuid_munged(&init_user_ns,
482 cifs_sb->mnt_backupuid));
483 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
484 seq_printf(s, ",backupgid=%u",
485 from_kgid_munged(&init_user_ns,
486 cifs_sb->mnt_backupgid));
488 seq_printf(s, ",rsize=%u", cifs_sb->rsize);
489 seq_printf(s, ",wsize=%u", cifs_sb->wsize);
490 /* convert actimeo and display it in seconds */
491 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
496 static void cifs_umount_begin(struct super_block *sb)
498 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
499 struct cifs_tcon *tcon;
504 tcon = cifs_sb_master_tcon(cifs_sb);
506 spin_lock(&cifs_tcp_ses_lock);
507 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
508 /* we have other mounts to same share or we have
509 already tried to force umount this and woken up
510 all waiting network requests, nothing to do */
511 spin_unlock(&cifs_tcp_ses_lock);
513 } else if (tcon->tc_count == 1)
514 tcon->tidStatus = CifsExiting;
515 spin_unlock(&cifs_tcp_ses_lock);
517 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
518 /* cancel_notify_requests(tcon); */
519 if (tcon->ses && tcon->ses->server) {
520 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
521 wake_up_all(&tcon->ses->server->request_q);
522 wake_up_all(&tcon->ses->server->response_q);
523 msleep(1); /* yield */
524 /* we have to kick the requests once more */
525 wake_up_all(&tcon->ses->server->response_q);
532 #ifdef CONFIG_CIFS_STATS2
533 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
540 static int cifs_remount(struct super_block *sb, int *flags, char *data)
542 *flags |= MS_NODIRATIME;
546 static int cifs_drop_inode(struct inode *inode)
548 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
550 /* no serverino => unconditional eviction */
551 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
552 generic_drop_inode(inode);
555 static const struct super_operations cifs_super_ops = {
556 .statfs = cifs_statfs,
557 .alloc_inode = cifs_alloc_inode,
558 .destroy_inode = cifs_destroy_inode,
559 .drop_inode = cifs_drop_inode,
560 .evict_inode = cifs_evict_inode,
561 /* .delete_inode = cifs_delete_inode, */ /* Do not need above
562 function unless later we add lazy close of inodes or unless the
563 kernel forgets to call us with the same number of releases (closes)
565 .show_options = cifs_show_options,
566 .umount_begin = cifs_umount_begin,
567 .remount_fs = cifs_remount,
568 #ifdef CONFIG_CIFS_STATS2
569 .show_stats = cifs_show_stats,
574 * Get root dentry from superblock according to prefix path mount option.
575 * Return dentry with refcount + 1 on success and NULL otherwise.
577 static struct dentry *
578 cifs_get_root(struct smb_vol *vol, struct super_block *sb)
580 struct dentry *dentry;
581 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
582 char *full_path = NULL;
586 full_path = cifs_build_path_to_root(vol, cifs_sb,
587 cifs_sb_master_tcon(cifs_sb));
588 if (full_path == NULL)
589 return ERR_PTR(-ENOMEM);
591 cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
593 sep = CIFS_DIR_SEP(cifs_sb);
594 dentry = dget(sb->s_root);
598 struct inode *dir = dentry->d_inode;
599 struct dentry *child;
603 dentry = ERR_PTR(-ENOENT);
606 if (!S_ISDIR(dir->i_mode)) {
608 dentry = ERR_PTR(-ENOTDIR);
612 /* skip separators */
619 while (*s && *s != sep)
622 mutex_lock(&dir->i_mutex);
623 child = lookup_one_len(p, dentry, s - p);
624 mutex_unlock(&dir->i_mutex);
627 } while (!IS_ERR(dentry));
632 static int cifs_set_super(struct super_block *sb, void *data)
634 struct cifs_mnt_data *mnt_data = data;
635 sb->s_fs_info = mnt_data->cifs_sb;
636 return set_anon_super(sb, NULL);
639 static struct dentry *
640 cifs_do_mount(struct file_system_type *fs_type,
641 int flags, const char *dev_name, void *data)
644 struct super_block *sb;
645 struct cifs_sb_info *cifs_sb;
646 struct smb_vol *volume_info;
647 struct cifs_mnt_data mnt_data;
650 cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
652 volume_info = cifs_get_volume_info((char *)data, dev_name);
653 if (IS_ERR(volume_info))
654 return ERR_CAST(volume_info);
656 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
657 if (cifs_sb == NULL) {
658 root = ERR_PTR(-ENOMEM);
662 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
663 if (cifs_sb->mountdata == NULL) {
664 root = ERR_PTR(-ENOMEM);
668 cifs_setup_cifs_sb(volume_info, cifs_sb);
670 rc = cifs_mount(cifs_sb, volume_info);
672 if (!(flags & MS_SILENT))
673 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
679 mnt_data.vol = volume_info;
680 mnt_data.cifs_sb = cifs_sb;
681 mnt_data.flags = flags;
683 /* BB should we make this contingent on mount parm? */
684 flags |= MS_NODIRATIME | MS_NOATIME;
686 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
689 cifs_umount(cifs_sb);
694 cifs_dbg(FYI, "Use existing superblock\n");
695 cifs_umount(cifs_sb);
697 rc = cifs_read_super(sb);
703 sb->s_flags |= MS_ACTIVE;
706 root = cifs_get_root(volume_info, sb);
710 cifs_dbg(FYI, "dentry root is: %p\n", root);
714 deactivate_locked_super(sb);
716 cifs_cleanup_volume_info(volume_info);
720 kfree(cifs_sb->mountdata);
724 unload_nls(volume_info->local_nls);
728 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
729 unsigned long nr_segs, loff_t pos)
731 struct inode *inode = file_inode(iocb->ki_filp);
735 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
737 if (CIFS_CACHE_WRITE(CIFS_I(inode)))
740 rc = filemap_fdatawrite(inode->i_mapping);
742 cifs_dbg(FYI, "cifs_file_aio_write: %d rc on %p inode\n",
748 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
751 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
752 * the cached file length
754 if (whence != SEEK_SET && whence != SEEK_CUR) {
756 struct inode *inode = file_inode(file);
759 * We need to be sure that all dirty pages are written and the
760 * server has the newest file length.
762 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
763 inode->i_mapping->nrpages != 0) {
764 rc = filemap_fdatawait(inode->i_mapping);
766 mapping_set_error(inode->i_mapping, rc);
771 * Some applications poll for the file length in this strange
772 * way so we must seek to end on non-oplocked files by
773 * setting the revalidate time to zero.
775 CIFS_I(inode)->time = 0;
777 rc = cifs_revalidate_file_attr(file);
781 return generic_file_llseek(file, offset, whence);
784 static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
787 * Note that this is called by vfs setlease with i_lock held to
788 * protect *lease from going away.
790 struct inode *inode = file_inode(file);
791 struct cifsFileInfo *cfile = file->private_data;
793 if (!(S_ISREG(inode->i_mode)))
796 /* check if file is oplocked */
797 if (((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
798 ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
799 return generic_setlease(file, arg, lease);
800 else if (tlink_tcon(cfile->tlink)->local_lease &&
801 !CIFS_CACHE_READ(CIFS_I(inode)))
803 * If the server claims to support oplock on this file, then we
804 * still need to check oplock even if the local_lease mount
805 * option is set, but there are servers which do not support
806 * oplock for which this mount option may be useful if the user
807 * knows that the file won't be changed on the server by anyone
810 return generic_setlease(file, arg, lease);
815 struct file_system_type cifs_fs_type = {
816 .owner = THIS_MODULE,
818 .mount = cifs_do_mount,
819 .kill_sb = cifs_kill_sb,
822 MODULE_ALIAS_FS("cifs");
823 const struct inode_operations cifs_dir_inode_ops = {
824 .create = cifs_create,
825 .atomic_open = cifs_atomic_open,
826 .lookup = cifs_lookup,
827 .getattr = cifs_getattr,
828 .unlink = cifs_unlink,
829 .link = cifs_hardlink,
832 .rename = cifs_rename,
833 .permission = cifs_permission,
834 /* revalidate:cifs_revalidate, */
835 .setattr = cifs_setattr,
836 .symlink = cifs_symlink,
838 #ifdef CONFIG_CIFS_XATTR
839 .setxattr = cifs_setxattr,
840 .getxattr = cifs_getxattr,
841 .listxattr = cifs_listxattr,
842 .removexattr = cifs_removexattr,
846 const struct inode_operations cifs_file_inode_ops = {
847 /* revalidate:cifs_revalidate, */
848 .setattr = cifs_setattr,
849 .getattr = cifs_getattr, /* do we need this anymore? */
850 .rename = cifs_rename,
851 .permission = cifs_permission,
852 #ifdef CONFIG_CIFS_XATTR
853 .setxattr = cifs_setxattr,
854 .getxattr = cifs_getxattr,
855 .listxattr = cifs_listxattr,
856 .removexattr = cifs_removexattr,
860 const struct inode_operations cifs_symlink_inode_ops = {
861 .readlink = generic_readlink,
862 .follow_link = cifs_follow_link,
863 .put_link = kfree_put_link,
864 .permission = cifs_permission,
865 /* BB add the following two eventually */
866 /* revalidate: cifs_revalidate,
867 setattr: cifs_notify_change, *//* BB do we need notify change */
868 #ifdef CONFIG_CIFS_XATTR
869 .setxattr = cifs_setxattr,
870 .getxattr = cifs_getxattr,
871 .listxattr = cifs_listxattr,
872 .removexattr = cifs_removexattr,
876 const struct file_operations cifs_file_ops = {
877 .read = do_sync_read,
878 .write = do_sync_write,
879 .aio_read = generic_file_aio_read,
880 .aio_write = cifs_file_aio_write,
882 .release = cifs_close,
886 .mmap = cifs_file_mmap,
887 .splice_read = generic_file_splice_read,
888 .llseek = cifs_llseek,
889 #ifdef CONFIG_CIFS_POSIX
890 .unlocked_ioctl = cifs_ioctl,
891 #endif /* CONFIG_CIFS_POSIX */
892 .setlease = cifs_setlease,
895 const struct file_operations cifs_file_strict_ops = {
896 .read = do_sync_read,
897 .write = do_sync_write,
898 .aio_read = cifs_strict_readv,
899 .aio_write = cifs_strict_writev,
901 .release = cifs_close,
903 .fsync = cifs_strict_fsync,
905 .mmap = cifs_file_strict_mmap,
906 .splice_read = generic_file_splice_read,
907 .llseek = cifs_llseek,
908 #ifdef CONFIG_CIFS_POSIX
909 .unlocked_ioctl = cifs_ioctl,
910 #endif /* CONFIG_CIFS_POSIX */
911 .setlease = cifs_setlease,
914 const struct file_operations cifs_file_direct_ops = {
915 /* BB reevaluate whether they can be done with directio, no cache */
916 .read = do_sync_read,
917 .write = do_sync_write,
918 .aio_read = cifs_user_readv,
919 .aio_write = cifs_user_writev,
921 .release = cifs_close,
925 .mmap = cifs_file_mmap,
926 .splice_read = generic_file_splice_read,
927 #ifdef CONFIG_CIFS_POSIX
928 .unlocked_ioctl = cifs_ioctl,
929 #endif /* CONFIG_CIFS_POSIX */
930 .llseek = cifs_llseek,
931 .setlease = cifs_setlease,
934 const struct file_operations cifs_file_nobrl_ops = {
935 .read = do_sync_read,
936 .write = do_sync_write,
937 .aio_read = generic_file_aio_read,
938 .aio_write = cifs_file_aio_write,
940 .release = cifs_close,
943 .mmap = cifs_file_mmap,
944 .splice_read = generic_file_splice_read,
945 .llseek = cifs_llseek,
946 #ifdef CONFIG_CIFS_POSIX
947 .unlocked_ioctl = cifs_ioctl,
948 #endif /* CONFIG_CIFS_POSIX */
949 .setlease = cifs_setlease,
952 const struct file_operations cifs_file_strict_nobrl_ops = {
953 .read = do_sync_read,
954 .write = do_sync_write,
955 .aio_read = cifs_strict_readv,
956 .aio_write = cifs_strict_writev,
958 .release = cifs_close,
959 .fsync = cifs_strict_fsync,
961 .mmap = cifs_file_strict_mmap,
962 .splice_read = generic_file_splice_read,
963 .llseek = cifs_llseek,
964 #ifdef CONFIG_CIFS_POSIX
965 .unlocked_ioctl = cifs_ioctl,
966 #endif /* CONFIG_CIFS_POSIX */
967 .setlease = cifs_setlease,
970 const struct file_operations cifs_file_direct_nobrl_ops = {
971 /* BB reevaluate whether they can be done with directio, no cache */
972 .read = do_sync_read,
973 .write = do_sync_write,
974 .aio_read = cifs_user_readv,
975 .aio_write = cifs_user_writev,
977 .release = cifs_close,
980 .mmap = cifs_file_mmap,
981 .splice_read = generic_file_splice_read,
982 #ifdef CONFIG_CIFS_POSIX
983 .unlocked_ioctl = cifs_ioctl,
984 #endif /* CONFIG_CIFS_POSIX */
985 .llseek = cifs_llseek,
986 .setlease = cifs_setlease,
989 const struct file_operations cifs_dir_ops = {
990 .iterate = cifs_readdir,
991 .release = cifs_closedir,
992 .read = generic_read_dir,
993 .unlocked_ioctl = cifs_ioctl,
994 .llseek = generic_file_llseek,
998 cifs_init_once(void *inode)
1000 struct cifsInodeInfo *cifsi = inode;
1002 inode_init_once(&cifsi->vfs_inode);
1003 init_rwsem(&cifsi->lock_sem);
1007 cifs_init_inodecache(void)
1009 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1010 sizeof(struct cifsInodeInfo),
1011 0, (SLAB_RECLAIM_ACCOUNT|
1014 if (cifs_inode_cachep == NULL)
1021 cifs_destroy_inodecache(void)
1024 * Make sure all delayed rcu free inodes are flushed before we
1028 kmem_cache_destroy(cifs_inode_cachep);
1032 cifs_init_request_bufs(void)
1034 size_t max_hdr_size = MAX_CIFS_HDR_SIZE;
1035 #ifdef CONFIG_CIFS_SMB2
1037 * SMB2 maximum header size is bigger than CIFS one - no problems to
1038 * allocate some more bytes for CIFS.
1040 max_hdr_size = MAX_SMB2_HDR_SIZE;
1042 if (CIFSMaxBufSize < 8192) {
1043 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1044 Unicode path name has to fit in any SMB/CIFS path based frames */
1045 CIFSMaxBufSize = 8192;
1046 } else if (CIFSMaxBufSize > 1024*127) {
1047 CIFSMaxBufSize = 1024 * 127;
1049 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1052 cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1053 CIFSMaxBufSize, CIFSMaxBufSize);
1055 cifs_req_cachep = kmem_cache_create("cifs_request",
1056 CIFSMaxBufSize + max_hdr_size, 0,
1057 SLAB_HWCACHE_ALIGN, NULL);
1058 if (cifs_req_cachep == NULL)
1061 if (cifs_min_rcv < 1)
1063 else if (cifs_min_rcv > 64) {
1065 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1068 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1071 if (cifs_req_poolp == NULL) {
1072 kmem_cache_destroy(cifs_req_cachep);
1075 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1076 almost all handle based requests (but not write response, nor is it
1077 sufficient for path based requests). A smaller size would have
1078 been more efficient (compacting multiple slab items on one 4k page)
1079 for the case in which debug was on, but this larger size allows
1080 more SMBs to use small buffer alloc and is still much more
1081 efficient to alloc 1 per page off the slab compared to 17K (5page)
1082 alloc of large cifs buffers even when page debugging is on */
1083 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
1084 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1086 if (cifs_sm_req_cachep == NULL) {
1087 mempool_destroy(cifs_req_poolp);
1088 kmem_cache_destroy(cifs_req_cachep);
1092 if (cifs_min_small < 2)
1094 else if (cifs_min_small > 256) {
1095 cifs_min_small = 256;
1096 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1099 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1100 cifs_sm_req_cachep);
1102 if (cifs_sm_req_poolp == NULL) {
1103 mempool_destroy(cifs_req_poolp);
1104 kmem_cache_destroy(cifs_req_cachep);
1105 kmem_cache_destroy(cifs_sm_req_cachep);
1113 cifs_destroy_request_bufs(void)
1115 mempool_destroy(cifs_req_poolp);
1116 kmem_cache_destroy(cifs_req_cachep);
1117 mempool_destroy(cifs_sm_req_poolp);
1118 kmem_cache_destroy(cifs_sm_req_cachep);
1122 cifs_init_mids(void)
1124 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1125 sizeof(struct mid_q_entry), 0,
1126 SLAB_HWCACHE_ALIGN, NULL);
1127 if (cifs_mid_cachep == NULL)
1130 /* 3 is a reasonable minimum number of simultaneous operations */
1131 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1132 if (cifs_mid_poolp == NULL) {
1133 kmem_cache_destroy(cifs_mid_cachep);
1141 cifs_destroy_mids(void)
1143 mempool_destroy(cifs_mid_poolp);
1144 kmem_cache_destroy(cifs_mid_cachep);
1152 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1153 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1154 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1155 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1156 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1158 * Initialize Global counters
1160 atomic_set(&sesInfoAllocCount, 0);
1161 atomic_set(&tconInfoAllocCount, 0);
1162 atomic_set(&tcpSesAllocCount, 0);
1163 atomic_set(&tcpSesReconnectCount, 0);
1164 atomic_set(&tconInfoReconnectCount, 0);
1166 atomic_set(&bufAllocCount, 0);
1167 atomic_set(&smBufAllocCount, 0);
1168 #ifdef CONFIG_CIFS_STATS2
1169 atomic_set(&totBufAllocCount, 0);
1170 atomic_set(&totSmBufAllocCount, 0);
1171 #endif /* CONFIG_CIFS_STATS2 */
1173 atomic_set(&midCount, 0);
1174 GlobalCurrentXid = 0;
1175 GlobalTotalActiveXid = 0;
1176 GlobalMaxActiveXid = 0;
1177 spin_lock_init(&cifs_tcp_ses_lock);
1178 spin_lock_init(&cifs_file_list_lock);
1179 spin_lock_init(&GlobalMid_Lock);
1181 #ifdef CONFIG_CIFS_SMB2
1182 get_random_bytes(cifs_client_guid, SMB2_CLIENT_GUID_SIZE);
1185 if (cifs_max_pending < 2) {
1186 cifs_max_pending = 2;
1187 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1188 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1189 cifs_max_pending = CIFS_MAX_REQ;
1190 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1194 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1197 goto out_clean_proc;
1200 rc = cifs_fscache_register();
1202 goto out_destroy_wq;
1204 rc = cifs_init_inodecache();
1206 goto out_unreg_fscache;
1208 rc = cifs_init_mids();
1210 goto out_destroy_inodecache;
1212 rc = cifs_init_request_bufs();
1214 goto out_destroy_mids;
1216 #ifdef CONFIG_CIFS_UPCALL
1217 rc = register_key_type(&cifs_spnego_key_type);
1219 goto out_destroy_request_bufs;
1220 #endif /* CONFIG_CIFS_UPCALL */
1222 #ifdef CONFIG_CIFS_ACL
1223 rc = init_cifs_idmap();
1225 goto out_register_key_type;
1226 #endif /* CONFIG_CIFS_ACL */
1228 rc = register_filesystem(&cifs_fs_type);
1230 goto out_init_cifs_idmap;
1234 out_init_cifs_idmap:
1235 #ifdef CONFIG_CIFS_ACL
1237 out_register_key_type:
1239 #ifdef CONFIG_CIFS_UPCALL
1240 unregister_key_type(&cifs_spnego_key_type);
1241 out_destroy_request_bufs:
1243 cifs_destroy_request_bufs();
1245 cifs_destroy_mids();
1246 out_destroy_inodecache:
1247 cifs_destroy_inodecache();
1249 cifs_fscache_unregister();
1251 destroy_workqueue(cifsiod_wq);
1260 cifs_dbg(NOISY, "exit_cifs\n");
1261 unregister_filesystem(&cifs_fs_type);
1262 cifs_dfs_release_automount_timer();
1263 #ifdef CONFIG_CIFS_ACL
1266 #ifdef CONFIG_CIFS_UPCALL
1267 unregister_key_type(&cifs_spnego_key_type);
1269 cifs_destroy_request_bufs();
1270 cifs_destroy_mids();
1271 cifs_destroy_inodecache();
1272 cifs_fscache_unregister();
1273 destroy_workqueue(cifsiod_wq);
1277 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1278 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1280 ("VFS to access servers complying with the SNIA CIFS Specification "
1281 "e.g. Samba and Windows");
1282 MODULE_VERSION(CIFS_VERSION);
1283 module_init(init_cifs)
1284 module_exit(exit_cifs)