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;
91 * Bumps refcount for cifs super block.
92 * Note that it should be only called if a referece to VFS super block is
93 * already held, e.g. in open-type syscalls context. Otherwise it can race with
94 * atomic_dec_and_test in deactivate_locked_super.
97 cifs_sb_active(struct super_block *sb)
99 struct cifs_sb_info *server = CIFS_SB(sb);
101 if (atomic_inc_return(&server->active) == 1)
102 atomic_inc(&sb->s_active);
106 cifs_sb_deactive(struct super_block *sb)
108 struct cifs_sb_info *server = CIFS_SB(sb);
110 if (atomic_dec_and_test(&server->active))
111 deactivate_super(sb);
115 cifs_read_super(struct super_block *sb)
118 struct cifs_sb_info *cifs_sb;
119 struct cifs_tcon *tcon;
122 cifs_sb = CIFS_SB(sb);
123 tcon = cifs_sb_master_tcon(cifs_sb);
125 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
126 sb->s_flags |= MS_POSIXACL;
128 if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
129 sb->s_maxbytes = MAX_LFS_FILESIZE;
131 sb->s_maxbytes = MAX_NON_LFS;
133 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
134 sb->s_time_gran = 100;
136 sb->s_magic = CIFS_MAGIC_NUMBER;
137 sb->s_op = &cifs_super_ops;
138 sb->s_bdi = &cifs_sb->bdi;
139 sb->s_blocksize = CIFS_MAX_MSGSIZE;
140 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
141 inode = cifs_root_iget(sb);
149 sb->s_d_op = &cifs_ci_dentry_ops;
151 sb->s_d_op = &cifs_dentry_ops;
153 sb->s_root = d_make_root(inode);
159 #ifdef CONFIG_CIFS_NFSD_EXPORT
160 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
161 cifs_dbg(FYI, "export ops supported\n");
162 sb->s_export_op = &cifs_export_ops;
164 #endif /* CONFIG_CIFS_NFSD_EXPORT */
169 cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
173 static void cifs_kill_sb(struct super_block *sb)
175 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
177 cifs_umount(cifs_sb);
181 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
183 struct super_block *sb = dentry->d_sb;
184 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
185 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
186 struct TCP_Server_Info *server = tcon->ses->server;
193 * PATH_MAX may be too long - it would presumably be total path,
194 * but note that some servers (includinng Samba 3) have a shorter
197 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
199 buf->f_namelen = PATH_MAX;
200 buf->f_files = 0; /* undefined */
201 buf->f_ffree = 0; /* unlimited */
203 if (server->ops->queryfs)
204 rc = server->ops->queryfs(xid, tcon, buf);
210 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
212 struct super_block *sb = file->f_path.dentry->d_sb;
213 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
214 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
215 struct TCP_Server_Info *server = tcon->ses->server;
217 if (server->ops->fallocate)
218 return server->ops->fallocate(file, tcon, mode, off, len);
223 static int cifs_permission(struct inode *inode, int mask)
225 struct cifs_sb_info *cifs_sb;
227 cifs_sb = CIFS_SB(inode->i_sb);
229 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
230 if ((mask & MAY_EXEC) && !execute_ok(inode))
234 } else /* file mode might have been restricted at mount time
235 on the client (above and beyond ACL on servers) for
236 servers which do not support setting and viewing mode bits,
237 so allowing client to check permissions is useful */
238 return generic_permission(inode, mask);
241 static struct kmem_cache *cifs_inode_cachep;
242 static struct kmem_cache *cifs_req_cachep;
243 static struct kmem_cache *cifs_mid_cachep;
244 static struct kmem_cache *cifs_sm_req_cachep;
245 mempool_t *cifs_sm_req_poolp;
246 mempool_t *cifs_req_poolp;
247 mempool_t *cifs_mid_poolp;
249 static struct inode *
250 cifs_alloc_inode(struct super_block *sb)
252 struct cifsInodeInfo *cifs_inode;
253 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
256 cifs_inode->cifsAttrs = 0x20; /* default */
257 cifs_inode->time = 0;
259 * Until the file is open and we have gotten oplock info back from the
260 * server, can not assume caching of file data or metadata.
262 cifs_set_oplock_level(cifs_inode, 0);
263 cifs_inode->flags = 0;
264 spin_lock_init(&cifs_inode->writers_lock);
265 cifs_inode->writers = 0;
266 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
267 cifs_inode->server_eof = 0;
268 cifs_inode->uniqueid = 0;
269 cifs_inode->createtime = 0;
270 cifs_inode->epoch = 0;
271 #ifdef CONFIG_CIFS_SMB2
272 get_random_bytes(cifs_inode->lease_key, SMB2_LEASE_KEY_SIZE);
275 * Can not set i_flags here - they get immediately overwritten to zero
278 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
279 INIT_LIST_HEAD(&cifs_inode->openFileList);
280 INIT_LIST_HEAD(&cifs_inode->llist);
281 return &cifs_inode->vfs_inode;
284 static void cifs_i_callback(struct rcu_head *head)
286 struct inode *inode = container_of(head, struct inode, i_rcu);
287 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
291 cifs_destroy_inode(struct inode *inode)
293 call_rcu(&inode->i_rcu, cifs_i_callback);
297 cifs_evict_inode(struct inode *inode)
299 truncate_inode_pages_final(&inode->i_data);
301 cifs_fscache_release_inode_cookie(inode);
305 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
307 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
308 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
310 seq_puts(s, ",addr=");
312 switch (server->dstaddr.ss_family) {
314 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
317 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
318 if (sa6->sin6_scope_id)
319 seq_printf(s, "%%%u", sa6->sin6_scope_id);
322 seq_puts(s, "(unknown)");
327 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
329 if (ses->sectype == Unspecified)
332 seq_puts(s, ",sec=");
334 switch (ses->sectype) {
336 seq_puts(s, "lanman");
339 seq_puts(s, "ntlmv2");
348 seq_puts(s, "ntlmssp");
351 /* shouldn't ever happen */
352 seq_puts(s, "unknown");
361 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
363 seq_puts(s, ",cache=");
365 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
366 seq_puts(s, "strict");
367 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
370 seq_puts(s, "loose");
374 cifs_show_nls(struct seq_file *s, struct nls_table *cur)
376 struct nls_table *def;
378 /* Display iocharset= option if it's not default charset */
379 def = load_nls_default();
381 seq_printf(s, ",iocharset=%s", cur->charset);
386 * cifs_show_options() is for displaying mount options in /proc/mounts.
387 * Not all settable options are displayed but most of the important
391 cifs_show_options(struct seq_file *s, struct dentry *root)
393 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
394 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
395 struct sockaddr *srcaddr;
396 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
398 seq_printf(s, ",vers=%s", tcon->ses->server->vals->version_string);
399 cifs_show_security(s, tcon->ses);
400 cifs_show_cache_flavor(s, cifs_sb);
402 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
403 seq_puts(s, ",multiuser");
404 else if (tcon->ses->user_name)
405 seq_printf(s, ",username=%s", tcon->ses->user_name);
407 if (tcon->ses->domainName)
408 seq_printf(s, ",domain=%s", tcon->ses->domainName);
410 if (srcaddr->sa_family != AF_UNSPEC) {
411 struct sockaddr_in *saddr4;
412 struct sockaddr_in6 *saddr6;
413 saddr4 = (struct sockaddr_in *)srcaddr;
414 saddr6 = (struct sockaddr_in6 *)srcaddr;
415 if (srcaddr->sa_family == AF_INET6)
416 seq_printf(s, ",srcaddr=%pI6c",
418 else if (srcaddr->sa_family == AF_INET)
419 seq_printf(s, ",srcaddr=%pI4",
420 &saddr4->sin_addr.s_addr);
422 seq_printf(s, ",srcaddr=BAD-AF:%i",
423 (int)(srcaddr->sa_family));
426 seq_printf(s, ",uid=%u",
427 from_kuid_munged(&init_user_ns, cifs_sb->mnt_uid));
428 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
429 seq_puts(s, ",forceuid");
431 seq_puts(s, ",noforceuid");
433 seq_printf(s, ",gid=%u",
434 from_kgid_munged(&init_user_ns, cifs_sb->mnt_gid));
435 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
436 seq_puts(s, ",forcegid");
438 seq_puts(s, ",noforcegid");
440 cifs_show_address(s, tcon->ses->server);
443 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
444 cifs_sb->mnt_file_mode,
445 cifs_sb->mnt_dir_mode);
447 cifs_show_nls(s, cifs_sb->local_nls);
450 seq_puts(s, ",seal");
452 seq_puts(s, ",nocase");
454 seq_puts(s, ",hard");
456 seq_puts(s, ",unix");
458 seq_puts(s, ",nounix");
459 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
460 seq_puts(s, ",posixpaths");
461 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
462 seq_puts(s, ",setuids");
463 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
464 seq_puts(s, ",serverino");
465 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
466 seq_puts(s, ",rwpidforward");
467 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
468 seq_puts(s, ",forcemand");
469 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
470 seq_puts(s, ",nouser_xattr");
471 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
472 seq_puts(s, ",mapchars");
473 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
475 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
476 seq_puts(s, ",nobrl");
477 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
478 seq_puts(s, ",cifsacl");
479 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
480 seq_puts(s, ",dynperm");
481 if (root->d_sb->s_flags & MS_POSIXACL)
483 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
484 seq_puts(s, ",mfsymlinks");
485 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
487 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
488 seq_puts(s, ",nostrictsync");
489 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
490 seq_puts(s, ",noperm");
491 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
492 seq_printf(s, ",backupuid=%u",
493 from_kuid_munged(&init_user_ns,
494 cifs_sb->mnt_backupuid));
495 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
496 seq_printf(s, ",backupgid=%u",
497 from_kgid_munged(&init_user_ns,
498 cifs_sb->mnt_backupgid));
500 seq_printf(s, ",rsize=%u", cifs_sb->rsize);
501 seq_printf(s, ",wsize=%u", cifs_sb->wsize);
502 /* convert actimeo and display it in seconds */
503 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
508 static void cifs_umount_begin(struct super_block *sb)
510 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
511 struct cifs_tcon *tcon;
516 tcon = cifs_sb_master_tcon(cifs_sb);
518 spin_lock(&cifs_tcp_ses_lock);
519 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
520 /* we have other mounts to same share or we have
521 already tried to force umount this and woken up
522 all waiting network requests, nothing to do */
523 spin_unlock(&cifs_tcp_ses_lock);
525 } else if (tcon->tc_count == 1)
526 tcon->tidStatus = CifsExiting;
527 spin_unlock(&cifs_tcp_ses_lock);
529 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
530 /* cancel_notify_requests(tcon); */
531 if (tcon->ses && tcon->ses->server) {
532 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
533 wake_up_all(&tcon->ses->server->request_q);
534 wake_up_all(&tcon->ses->server->response_q);
535 msleep(1); /* yield */
536 /* we have to kick the requests once more */
537 wake_up_all(&tcon->ses->server->response_q);
544 #ifdef CONFIG_CIFS_STATS2
545 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
552 static int cifs_remount(struct super_block *sb, int *flags, char *data)
555 *flags |= MS_NODIRATIME;
559 static int cifs_drop_inode(struct inode *inode)
561 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
563 /* no serverino => unconditional eviction */
564 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
565 generic_drop_inode(inode);
568 static const struct super_operations cifs_super_ops = {
569 .statfs = cifs_statfs,
570 .alloc_inode = cifs_alloc_inode,
571 .destroy_inode = cifs_destroy_inode,
572 .drop_inode = cifs_drop_inode,
573 .evict_inode = cifs_evict_inode,
574 /* .delete_inode = cifs_delete_inode, */ /* Do not need above
575 function unless later we add lazy close of inodes or unless the
576 kernel forgets to call us with the same number of releases (closes)
578 .show_options = cifs_show_options,
579 .umount_begin = cifs_umount_begin,
580 .remount_fs = cifs_remount,
581 #ifdef CONFIG_CIFS_STATS2
582 .show_stats = cifs_show_stats,
587 * Get root dentry from superblock according to prefix path mount option.
588 * Return dentry with refcount + 1 on success and NULL otherwise.
590 static struct dentry *
591 cifs_get_root(struct smb_vol *vol, struct super_block *sb)
593 struct dentry *dentry;
594 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
595 char *full_path = NULL;
599 full_path = cifs_build_path_to_root(vol, cifs_sb,
600 cifs_sb_master_tcon(cifs_sb));
601 if (full_path == NULL)
602 return ERR_PTR(-ENOMEM);
604 cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
606 sep = CIFS_DIR_SEP(cifs_sb);
607 dentry = dget(sb->s_root);
611 struct inode *dir = dentry->d_inode;
612 struct dentry *child;
616 dentry = ERR_PTR(-ENOENT);
619 if (!S_ISDIR(dir->i_mode)) {
621 dentry = ERR_PTR(-ENOTDIR);
625 /* skip separators */
632 while (*s && *s != sep)
635 mutex_lock(&dir->i_mutex);
636 child = lookup_one_len(p, dentry, s - p);
637 mutex_unlock(&dir->i_mutex);
640 } while (!IS_ERR(dentry));
645 static int cifs_set_super(struct super_block *sb, void *data)
647 struct cifs_mnt_data *mnt_data = data;
648 sb->s_fs_info = mnt_data->cifs_sb;
649 return set_anon_super(sb, NULL);
652 static struct dentry *
653 cifs_do_mount(struct file_system_type *fs_type,
654 int flags, const char *dev_name, void *data)
657 struct super_block *sb;
658 struct cifs_sb_info *cifs_sb;
659 struct smb_vol *volume_info;
660 struct cifs_mnt_data mnt_data;
663 cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
665 volume_info = cifs_get_volume_info((char *)data, dev_name);
666 if (IS_ERR(volume_info))
667 return ERR_CAST(volume_info);
669 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
670 if (cifs_sb == NULL) {
671 root = ERR_PTR(-ENOMEM);
675 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
676 if (cifs_sb->mountdata == NULL) {
677 root = ERR_PTR(-ENOMEM);
681 cifs_setup_cifs_sb(volume_info, cifs_sb);
683 rc = cifs_mount(cifs_sb, volume_info);
685 if (!(flags & MS_SILENT))
686 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
692 mnt_data.vol = volume_info;
693 mnt_data.cifs_sb = cifs_sb;
694 mnt_data.flags = flags;
696 /* BB should we make this contingent on mount parm? */
697 flags |= MS_NODIRATIME | MS_NOATIME;
699 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
702 cifs_umount(cifs_sb);
707 cifs_dbg(FYI, "Use existing superblock\n");
708 cifs_umount(cifs_sb);
710 rc = cifs_read_super(sb);
716 sb->s_flags |= MS_ACTIVE;
719 root = cifs_get_root(volume_info, sb);
723 cifs_dbg(FYI, "dentry root is: %p\n", root);
727 deactivate_locked_super(sb);
729 cifs_cleanup_volume_info(volume_info);
733 kfree(cifs_sb->mountdata);
737 unload_nls(volume_info->local_nls);
742 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
745 struct inode *inode = file_inode(iocb->ki_filp);
747 rc = cifs_revalidate_mapping(inode);
751 return generic_file_read_iter(iocb, iter);
754 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
756 struct inode *inode = file_inode(iocb->ki_filp);
757 struct cifsInodeInfo *cinode = CIFS_I(inode);
761 written = cifs_get_writer(cinode);
765 written = generic_file_write_iter(iocb, from);
767 if (CIFS_CACHE_WRITE(CIFS_I(inode)))
770 rc = filemap_fdatawrite(inode->i_mapping);
772 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
776 cifs_put_writer(cinode);
780 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
783 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
784 * the cached file length
786 if (whence != SEEK_SET && whence != SEEK_CUR) {
788 struct inode *inode = file_inode(file);
791 * We need to be sure that all dirty pages are written and the
792 * server has the newest file length.
794 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
795 inode->i_mapping->nrpages != 0) {
796 rc = filemap_fdatawait(inode->i_mapping);
798 mapping_set_error(inode->i_mapping, rc);
803 * Some applications poll for the file length in this strange
804 * way so we must seek to end on non-oplocked files by
805 * setting the revalidate time to zero.
807 CIFS_I(inode)->time = 0;
809 rc = cifs_revalidate_file_attr(file);
813 return generic_file_llseek(file, offset, whence);
816 static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
819 * Note that this is called by vfs setlease with i_lock held to
820 * protect *lease from going away.
822 struct inode *inode = file_inode(file);
823 struct cifsFileInfo *cfile = file->private_data;
825 if (!(S_ISREG(inode->i_mode)))
828 /* Check if file is oplocked if this is request for new lease */
829 if (arg == F_UNLCK ||
830 ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
831 ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
832 return generic_setlease(file, arg, lease);
833 else if (tlink_tcon(cfile->tlink)->local_lease &&
834 !CIFS_CACHE_READ(CIFS_I(inode)))
836 * If the server claims to support oplock on this file, then we
837 * still need to check oplock even if the local_lease mount
838 * option is set, but there are servers which do not support
839 * oplock for which this mount option may be useful if the user
840 * knows that the file won't be changed on the server by anyone
843 return generic_setlease(file, arg, lease);
848 struct file_system_type cifs_fs_type = {
849 .owner = THIS_MODULE,
851 .mount = cifs_do_mount,
852 .kill_sb = cifs_kill_sb,
855 MODULE_ALIAS_FS("cifs");
856 const struct inode_operations cifs_dir_inode_ops = {
857 .create = cifs_create,
858 .atomic_open = cifs_atomic_open,
859 .lookup = cifs_lookup,
860 .getattr = cifs_getattr,
861 .unlink = cifs_unlink,
862 .link = cifs_hardlink,
865 .rename2 = cifs_rename2,
866 .permission = cifs_permission,
867 /* revalidate:cifs_revalidate, */
868 .setattr = cifs_setattr,
869 .symlink = cifs_symlink,
871 #ifdef CONFIG_CIFS_XATTR
872 .setxattr = cifs_setxattr,
873 .getxattr = cifs_getxattr,
874 .listxattr = cifs_listxattr,
875 .removexattr = cifs_removexattr,
879 const struct inode_operations cifs_file_inode_ops = {
880 /* revalidate:cifs_revalidate, */
881 .setattr = cifs_setattr,
882 .getattr = cifs_getattr, /* do we need this anymore? */
883 .permission = cifs_permission,
884 #ifdef CONFIG_CIFS_XATTR
885 .setxattr = cifs_setxattr,
886 .getxattr = cifs_getxattr,
887 .listxattr = cifs_listxattr,
888 .removexattr = cifs_removexattr,
892 const struct inode_operations cifs_symlink_inode_ops = {
893 .readlink = generic_readlink,
894 .follow_link = cifs_follow_link,
895 .put_link = kfree_put_link,
896 .permission = cifs_permission,
897 /* BB add the following two eventually */
898 /* revalidate: cifs_revalidate,
899 setattr: cifs_notify_change, *//* BB do we need notify change */
900 #ifdef CONFIG_CIFS_XATTR
901 .setxattr = cifs_setxattr,
902 .getxattr = cifs_getxattr,
903 .listxattr = cifs_listxattr,
904 .removexattr = cifs_removexattr,
908 const struct file_operations cifs_file_ops = {
909 .read = new_sync_read,
910 .write = new_sync_write,
911 .read_iter = cifs_loose_read_iter,
912 .write_iter = cifs_file_write_iter,
914 .release = cifs_close,
918 .mmap = cifs_file_mmap,
919 .splice_read = generic_file_splice_read,
920 .llseek = cifs_llseek,
921 #ifdef CONFIG_CIFS_POSIX
922 .unlocked_ioctl = cifs_ioctl,
923 #endif /* CONFIG_CIFS_POSIX */
924 .setlease = cifs_setlease,
925 .fallocate = cifs_fallocate,
928 const struct file_operations cifs_file_strict_ops = {
929 .read = new_sync_read,
930 .write = new_sync_write,
931 .read_iter = cifs_strict_readv,
932 .write_iter = cifs_strict_writev,
934 .release = cifs_close,
936 .fsync = cifs_strict_fsync,
938 .mmap = cifs_file_strict_mmap,
939 .splice_read = generic_file_splice_read,
940 .llseek = cifs_llseek,
941 #ifdef CONFIG_CIFS_POSIX
942 .unlocked_ioctl = cifs_ioctl,
943 #endif /* CONFIG_CIFS_POSIX */
944 .setlease = cifs_setlease,
945 .fallocate = cifs_fallocate,
948 const struct file_operations cifs_file_direct_ops = {
949 /* BB reevaluate whether they can be done with directio, no cache */
950 .read = new_sync_read,
951 .write = new_sync_write,
952 .read_iter = cifs_user_readv,
953 .write_iter = cifs_user_writev,
955 .release = cifs_close,
959 .mmap = cifs_file_mmap,
960 .splice_read = generic_file_splice_read,
961 #ifdef CONFIG_CIFS_POSIX
962 .unlocked_ioctl = cifs_ioctl,
963 #endif /* CONFIG_CIFS_POSIX */
964 .llseek = cifs_llseek,
965 .setlease = cifs_setlease,
966 .fallocate = cifs_fallocate,
969 const struct file_operations cifs_file_nobrl_ops = {
970 .read = new_sync_read,
971 .write = new_sync_write,
972 .read_iter = cifs_loose_read_iter,
973 .write_iter = cifs_file_write_iter,
975 .release = cifs_close,
978 .mmap = cifs_file_mmap,
979 .splice_read = generic_file_splice_read,
980 .llseek = cifs_llseek,
981 #ifdef CONFIG_CIFS_POSIX
982 .unlocked_ioctl = cifs_ioctl,
983 #endif /* CONFIG_CIFS_POSIX */
984 .setlease = cifs_setlease,
985 .fallocate = cifs_fallocate,
988 const struct file_operations cifs_file_strict_nobrl_ops = {
989 .read = new_sync_read,
990 .write = new_sync_write,
991 .read_iter = cifs_strict_readv,
992 .write_iter = cifs_strict_writev,
994 .release = cifs_close,
995 .fsync = cifs_strict_fsync,
997 .mmap = cifs_file_strict_mmap,
998 .splice_read = generic_file_splice_read,
999 .llseek = cifs_llseek,
1000 #ifdef CONFIG_CIFS_POSIX
1001 .unlocked_ioctl = cifs_ioctl,
1002 #endif /* CONFIG_CIFS_POSIX */
1003 .setlease = cifs_setlease,
1004 .fallocate = cifs_fallocate,
1007 const struct file_operations cifs_file_direct_nobrl_ops = {
1008 /* BB reevaluate whether they can be done with directio, no cache */
1009 .read = new_sync_read,
1010 .write = new_sync_write,
1011 .read_iter = cifs_user_readv,
1012 .write_iter = cifs_user_writev,
1014 .release = cifs_close,
1015 .fsync = cifs_fsync,
1016 .flush = cifs_flush,
1017 .mmap = cifs_file_mmap,
1018 .splice_read = generic_file_splice_read,
1019 #ifdef CONFIG_CIFS_POSIX
1020 .unlocked_ioctl = cifs_ioctl,
1021 #endif /* CONFIG_CIFS_POSIX */
1022 .llseek = cifs_llseek,
1023 .setlease = cifs_setlease,
1024 .fallocate = cifs_fallocate,
1027 const struct file_operations cifs_dir_ops = {
1028 .iterate = cifs_readdir,
1029 .release = cifs_closedir,
1030 .read = generic_read_dir,
1031 .unlocked_ioctl = cifs_ioctl,
1032 .llseek = generic_file_llseek,
1036 cifs_init_once(void *inode)
1038 struct cifsInodeInfo *cifsi = inode;
1040 inode_init_once(&cifsi->vfs_inode);
1041 init_rwsem(&cifsi->lock_sem);
1045 cifs_init_inodecache(void)
1047 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1048 sizeof(struct cifsInodeInfo),
1049 0, (SLAB_RECLAIM_ACCOUNT|
1052 if (cifs_inode_cachep == NULL)
1059 cifs_destroy_inodecache(void)
1062 * Make sure all delayed rcu free inodes are flushed before we
1066 kmem_cache_destroy(cifs_inode_cachep);
1070 cifs_init_request_bufs(void)
1072 size_t max_hdr_size = MAX_CIFS_HDR_SIZE;
1073 #ifdef CONFIG_CIFS_SMB2
1075 * SMB2 maximum header size is bigger than CIFS one - no problems to
1076 * allocate some more bytes for CIFS.
1078 max_hdr_size = MAX_SMB2_HDR_SIZE;
1080 if (CIFSMaxBufSize < 8192) {
1081 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1082 Unicode path name has to fit in any SMB/CIFS path based frames */
1083 CIFSMaxBufSize = 8192;
1084 } else if (CIFSMaxBufSize > 1024*127) {
1085 CIFSMaxBufSize = 1024 * 127;
1087 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1090 cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1091 CIFSMaxBufSize, CIFSMaxBufSize);
1093 cifs_req_cachep = kmem_cache_create("cifs_request",
1094 CIFSMaxBufSize + max_hdr_size, 0,
1095 SLAB_HWCACHE_ALIGN, NULL);
1096 if (cifs_req_cachep == NULL)
1099 if (cifs_min_rcv < 1)
1101 else if (cifs_min_rcv > 64) {
1103 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1106 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1109 if (cifs_req_poolp == NULL) {
1110 kmem_cache_destroy(cifs_req_cachep);
1113 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1114 almost all handle based requests (but not write response, nor is it
1115 sufficient for path based requests). A smaller size would have
1116 been more efficient (compacting multiple slab items on one 4k page)
1117 for the case in which debug was on, but this larger size allows
1118 more SMBs to use small buffer alloc and is still much more
1119 efficient to alloc 1 per page off the slab compared to 17K (5page)
1120 alloc of large cifs buffers even when page debugging is on */
1121 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
1122 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1124 if (cifs_sm_req_cachep == NULL) {
1125 mempool_destroy(cifs_req_poolp);
1126 kmem_cache_destroy(cifs_req_cachep);
1130 if (cifs_min_small < 2)
1132 else if (cifs_min_small > 256) {
1133 cifs_min_small = 256;
1134 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1137 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1138 cifs_sm_req_cachep);
1140 if (cifs_sm_req_poolp == NULL) {
1141 mempool_destroy(cifs_req_poolp);
1142 kmem_cache_destroy(cifs_req_cachep);
1143 kmem_cache_destroy(cifs_sm_req_cachep);
1151 cifs_destroy_request_bufs(void)
1153 mempool_destroy(cifs_req_poolp);
1154 kmem_cache_destroy(cifs_req_cachep);
1155 mempool_destroy(cifs_sm_req_poolp);
1156 kmem_cache_destroy(cifs_sm_req_cachep);
1160 cifs_init_mids(void)
1162 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1163 sizeof(struct mid_q_entry), 0,
1164 SLAB_HWCACHE_ALIGN, NULL);
1165 if (cifs_mid_cachep == NULL)
1168 /* 3 is a reasonable minimum number of simultaneous operations */
1169 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1170 if (cifs_mid_poolp == NULL) {
1171 kmem_cache_destroy(cifs_mid_cachep);
1179 cifs_destroy_mids(void)
1181 mempool_destroy(cifs_mid_poolp);
1182 kmem_cache_destroy(cifs_mid_cachep);
1190 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1191 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1192 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1193 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1194 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1196 * Initialize Global counters
1198 atomic_set(&sesInfoAllocCount, 0);
1199 atomic_set(&tconInfoAllocCount, 0);
1200 atomic_set(&tcpSesAllocCount, 0);
1201 atomic_set(&tcpSesReconnectCount, 0);
1202 atomic_set(&tconInfoReconnectCount, 0);
1204 atomic_set(&bufAllocCount, 0);
1205 atomic_set(&smBufAllocCount, 0);
1206 #ifdef CONFIG_CIFS_STATS2
1207 atomic_set(&totBufAllocCount, 0);
1208 atomic_set(&totSmBufAllocCount, 0);
1209 #endif /* CONFIG_CIFS_STATS2 */
1211 atomic_set(&midCount, 0);
1212 GlobalCurrentXid = 0;
1213 GlobalTotalActiveXid = 0;
1214 GlobalMaxActiveXid = 0;
1215 spin_lock_init(&cifs_tcp_ses_lock);
1216 spin_lock_init(&cifs_file_list_lock);
1217 spin_lock_init(&GlobalMid_Lock);
1219 if (cifs_max_pending < 2) {
1220 cifs_max_pending = 2;
1221 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1222 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1223 cifs_max_pending = CIFS_MAX_REQ;
1224 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1228 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1231 goto out_clean_proc;
1234 rc = cifs_fscache_register();
1236 goto out_destroy_wq;
1238 rc = cifs_init_inodecache();
1240 goto out_unreg_fscache;
1242 rc = cifs_init_mids();
1244 goto out_destroy_inodecache;
1246 rc = cifs_init_request_bufs();
1248 goto out_destroy_mids;
1250 #ifdef CONFIG_CIFS_UPCALL
1251 rc = register_key_type(&cifs_spnego_key_type);
1253 goto out_destroy_request_bufs;
1254 #endif /* CONFIG_CIFS_UPCALL */
1256 #ifdef CONFIG_CIFS_ACL
1257 rc = init_cifs_idmap();
1259 goto out_register_key_type;
1260 #endif /* CONFIG_CIFS_ACL */
1262 rc = register_filesystem(&cifs_fs_type);
1264 goto out_init_cifs_idmap;
1268 out_init_cifs_idmap:
1269 #ifdef CONFIG_CIFS_ACL
1271 out_register_key_type:
1273 #ifdef CONFIG_CIFS_UPCALL
1274 unregister_key_type(&cifs_spnego_key_type);
1275 out_destroy_request_bufs:
1277 cifs_destroy_request_bufs();
1279 cifs_destroy_mids();
1280 out_destroy_inodecache:
1281 cifs_destroy_inodecache();
1283 cifs_fscache_unregister();
1285 destroy_workqueue(cifsiod_wq);
1294 cifs_dbg(NOISY, "exit_cifs\n");
1295 unregister_filesystem(&cifs_fs_type);
1296 cifs_dfs_release_automount_timer();
1297 #ifdef CONFIG_CIFS_ACL
1300 #ifdef CONFIG_CIFS_UPCALL
1301 unregister_key_type(&cifs_spnego_key_type);
1303 cifs_destroy_request_bufs();
1304 cifs_destroy_mids();
1305 cifs_destroy_inodecache();
1306 cifs_fscache_unregister();
1307 destroy_workqueue(cifsiod_wq);
1311 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1312 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1314 ("VFS to access servers complying with the SNIA CIFS Specification "
1315 "e.g. Samba and Windows");
1316 MODULE_VERSION(CIFS_VERSION);
1317 module_init(init_cifs)
1318 module_exit(exit_cifs)