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>
40 #include <linux/xattr.h>
44 #define DECLARE_GLOBALS_HERE
46 #include "cifsproto.h"
47 #include "cifs_debug.h"
48 #include "cifs_fs_sb.h"
50 #include <linux/key-type.h>
51 #include "cifs_spnego.h"
53 #ifdef CONFIG_CIFS_SMB2
59 bool enable_oplocks = true;
60 bool linuxExtEnabled = true;
61 bool lookupCacheEnabled = true;
62 unsigned int global_secflags = CIFSSEC_DEF;
63 /* unsigned int ntlmv2_support = 0; */
64 unsigned int sign_CIFS_PDUs = 1;
65 static const struct super_operations cifs_super_ops;
66 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
67 module_param(CIFSMaxBufSize, uint, 0444);
68 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
69 "Default: 16384 Range: 8192 to 130048");
70 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
71 module_param(cifs_min_rcv, uint, 0444);
72 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
74 unsigned int cifs_min_small = 30;
75 module_param(cifs_min_small, uint, 0444);
76 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
78 unsigned int cifs_max_pending = CIFS_MAX_REQ;
79 module_param(cifs_max_pending, uint, 0444);
80 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
81 "Default: 32767 Range: 2 to 32767.");
82 module_param(enable_oplocks, bool, 0644);
83 MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
85 extern mempool_t *cifs_sm_req_poolp;
86 extern mempool_t *cifs_req_poolp;
87 extern mempool_t *cifs_mid_poolp;
89 struct workqueue_struct *cifsiod_wq;
90 __u32 cifs_lock_secret;
93 * Bumps refcount for cifs super block.
94 * Note that it should be only called if a referece to VFS super block is
95 * already held, e.g. in open-type syscalls context. Otherwise it can race with
96 * atomic_dec_and_test in deactivate_locked_super.
99 cifs_sb_active(struct super_block *sb)
101 struct cifs_sb_info *server = CIFS_SB(sb);
103 if (atomic_inc_return(&server->active) == 1)
104 atomic_inc(&sb->s_active);
108 cifs_sb_deactive(struct super_block *sb)
110 struct cifs_sb_info *server = CIFS_SB(sb);
112 if (atomic_dec_and_test(&server->active))
113 deactivate_super(sb);
117 cifs_read_super(struct super_block *sb)
120 struct cifs_sb_info *cifs_sb;
121 struct cifs_tcon *tcon;
124 cifs_sb = CIFS_SB(sb);
125 tcon = cifs_sb_master_tcon(cifs_sb);
127 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
128 sb->s_flags |= MS_POSIXACL;
130 if (tcon->ses->capabilities & tcon->ses->server->vals->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_xattr = cifs_xattr_handlers;
141 rc = super_setup_bdi(sb);
144 /* tune readahead according to rsize */
145 sb->s_bdi->ra_pages = cifs_sb->rsize / PAGE_SIZE;
147 sb->s_blocksize = CIFS_MAX_MSGSIZE;
148 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
149 inode = cifs_root_iget(sb);
157 sb->s_d_op = &cifs_ci_dentry_ops;
159 sb->s_d_op = &cifs_dentry_ops;
161 sb->s_root = d_make_root(inode);
167 #ifdef CONFIG_CIFS_NFSD_EXPORT
168 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
169 cifs_dbg(FYI, "export ops supported\n");
170 sb->s_export_op = &cifs_export_ops;
172 #endif /* CONFIG_CIFS_NFSD_EXPORT */
177 cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
181 static void cifs_kill_sb(struct super_block *sb)
183 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
185 cifs_umount(cifs_sb);
189 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
191 struct super_block *sb = dentry->d_sb;
192 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
193 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
194 struct TCP_Server_Info *server = tcon->ses->server;
201 * PATH_MAX may be too long - it would presumably be total path,
202 * but note that some servers (includinng Samba 3) have a shorter
205 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
207 buf->f_namelen = PATH_MAX;
208 buf->f_files = 0; /* undefined */
209 buf->f_ffree = 0; /* unlimited */
211 if (server->ops->queryfs)
212 rc = server->ops->queryfs(xid, tcon, buf);
218 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
220 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
221 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
222 struct TCP_Server_Info *server = tcon->ses->server;
224 if (server->ops->fallocate)
225 return server->ops->fallocate(file, tcon, mode, off, len);
230 static int cifs_permission(struct inode *inode, int mask)
232 struct cifs_sb_info *cifs_sb;
234 cifs_sb = CIFS_SB(inode->i_sb);
236 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
237 if ((mask & MAY_EXEC) && !execute_ok(inode))
241 } else /* file mode might have been restricted at mount time
242 on the client (above and beyond ACL on servers) for
243 servers which do not support setting and viewing mode bits,
244 so allowing client to check permissions is useful */
245 return generic_permission(inode, mask);
248 static struct kmem_cache *cifs_inode_cachep;
249 static struct kmem_cache *cifs_req_cachep;
250 static struct kmem_cache *cifs_mid_cachep;
251 static struct kmem_cache *cifs_sm_req_cachep;
252 mempool_t *cifs_sm_req_poolp;
253 mempool_t *cifs_req_poolp;
254 mempool_t *cifs_mid_poolp;
256 static struct inode *
257 cifs_alloc_inode(struct super_block *sb)
259 struct cifsInodeInfo *cifs_inode;
260 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
263 cifs_inode->cifsAttrs = 0x20; /* default */
264 cifs_inode->time = 0;
266 * Until the file is open and we have gotten oplock info back from the
267 * server, can not assume caching of file data or metadata.
269 cifs_set_oplock_level(cifs_inode, 0);
270 cifs_inode->flags = 0;
271 spin_lock_init(&cifs_inode->writers_lock);
272 cifs_inode->writers = 0;
273 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
274 cifs_inode->server_eof = 0;
275 cifs_inode->uniqueid = 0;
276 cifs_inode->createtime = 0;
277 cifs_inode->epoch = 0;
278 #ifdef CONFIG_CIFS_SMB2
279 generate_random_uuid(cifs_inode->lease_key);
282 * Can not set i_flags here - they get immediately overwritten to zero
285 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
286 INIT_LIST_HEAD(&cifs_inode->openFileList);
287 INIT_LIST_HEAD(&cifs_inode->llist);
288 return &cifs_inode->vfs_inode;
291 static void cifs_i_callback(struct rcu_head *head)
293 struct inode *inode = container_of(head, struct inode, i_rcu);
294 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
298 cifs_destroy_inode(struct inode *inode)
300 call_rcu(&inode->i_rcu, cifs_i_callback);
304 cifs_evict_inode(struct inode *inode)
306 truncate_inode_pages_final(&inode->i_data);
308 cifs_fscache_release_inode_cookie(inode);
312 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
314 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
315 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
317 seq_puts(s, ",addr=");
319 switch (server->dstaddr.ss_family) {
321 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
324 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
325 if (sa6->sin6_scope_id)
326 seq_printf(s, "%%%u", sa6->sin6_scope_id);
329 seq_puts(s, "(unknown)");
334 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
336 if (ses->sectype == Unspecified) {
337 if (ses->user_name == NULL)
338 seq_puts(s, ",sec=none");
342 seq_puts(s, ",sec=");
344 switch (ses->sectype) {
346 seq_puts(s, "lanman");
349 seq_puts(s, "ntlmv2");
358 seq_puts(s, "ntlmssp");
361 /* shouldn't ever happen */
362 seq_puts(s, "unknown");
371 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
373 seq_puts(s, ",cache=");
375 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
376 seq_puts(s, "strict");
377 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
380 seq_puts(s, "loose");
384 cifs_show_nls(struct seq_file *s, struct nls_table *cur)
386 struct nls_table *def;
388 /* Display iocharset= option if it's not default charset */
389 def = load_nls_default();
391 seq_printf(s, ",iocharset=%s", cur->charset);
396 * cifs_show_options() is for displaying mount options in /proc/mounts.
397 * Not all settable options are displayed but most of the important
401 cifs_show_options(struct seq_file *s, struct dentry *root)
403 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
404 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
405 struct sockaddr *srcaddr;
406 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
408 seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
409 cifs_show_security(s, tcon->ses);
410 cifs_show_cache_flavor(s, cifs_sb);
412 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
413 seq_puts(s, ",multiuser");
414 else if (tcon->ses->user_name)
415 seq_show_option(s, "username", tcon->ses->user_name);
417 if (tcon->ses->domainName)
418 seq_show_option(s, "domain", tcon->ses->domainName);
420 if (srcaddr->sa_family != AF_UNSPEC) {
421 struct sockaddr_in *saddr4;
422 struct sockaddr_in6 *saddr6;
423 saddr4 = (struct sockaddr_in *)srcaddr;
424 saddr6 = (struct sockaddr_in6 *)srcaddr;
425 if (srcaddr->sa_family == AF_INET6)
426 seq_printf(s, ",srcaddr=%pI6c",
428 else if (srcaddr->sa_family == AF_INET)
429 seq_printf(s, ",srcaddr=%pI4",
430 &saddr4->sin_addr.s_addr);
432 seq_printf(s, ",srcaddr=BAD-AF:%i",
433 (int)(srcaddr->sa_family));
436 seq_printf(s, ",uid=%u",
437 from_kuid_munged(&init_user_ns, cifs_sb->mnt_uid));
438 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
439 seq_puts(s, ",forceuid");
441 seq_puts(s, ",noforceuid");
443 seq_printf(s, ",gid=%u",
444 from_kgid_munged(&init_user_ns, cifs_sb->mnt_gid));
445 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
446 seq_puts(s, ",forcegid");
448 seq_puts(s, ",noforcegid");
450 cifs_show_address(s, tcon->ses->server);
453 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
454 cifs_sb->mnt_file_mode,
455 cifs_sb->mnt_dir_mode);
457 cifs_show_nls(s, cifs_sb->local_nls);
460 seq_puts(s, ",seal");
462 seq_puts(s, ",nocase");
464 seq_puts(s, ",hard");
465 if (tcon->use_persistent)
466 seq_puts(s, ",persistenthandles");
467 else if (tcon->use_resilient)
468 seq_puts(s, ",resilienthandles");
470 seq_puts(s, ",unix");
472 seq_puts(s, ",nounix");
473 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
474 seq_puts(s, ",posixpaths");
475 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
476 seq_puts(s, ",setuids");
477 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
478 seq_puts(s, ",idsfromsid");
479 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
480 seq_puts(s, ",serverino");
481 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
482 seq_puts(s, ",rwpidforward");
483 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
484 seq_puts(s, ",forcemand");
485 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
486 seq_puts(s, ",nouser_xattr");
487 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
488 seq_puts(s, ",mapchars");
489 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
490 seq_puts(s, ",mapposix");
491 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
493 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
494 seq_puts(s, ",nobrl");
495 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
496 seq_puts(s, ",cifsacl");
497 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
498 seq_puts(s, ",dynperm");
499 if (root->d_sb->s_flags & MS_POSIXACL)
501 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
502 seq_puts(s, ",mfsymlinks");
503 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
505 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
506 seq_puts(s, ",nostrictsync");
507 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
508 seq_puts(s, ",noperm");
509 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
510 seq_printf(s, ",backupuid=%u",
511 from_kuid_munged(&init_user_ns,
512 cifs_sb->mnt_backupuid));
513 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
514 seq_printf(s, ",backupgid=%u",
515 from_kgid_munged(&init_user_ns,
516 cifs_sb->mnt_backupgid));
518 seq_printf(s, ",rsize=%u", cifs_sb->rsize);
519 seq_printf(s, ",wsize=%u", cifs_sb->wsize);
520 seq_printf(s, ",echo_interval=%lu",
521 tcon->ses->server->echo_interval / HZ);
522 /* convert actimeo and display it in seconds */
523 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
528 static void cifs_umount_begin(struct super_block *sb)
530 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
531 struct cifs_tcon *tcon;
536 tcon = cifs_sb_master_tcon(cifs_sb);
538 spin_lock(&cifs_tcp_ses_lock);
539 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
540 /* we have other mounts to same share or we have
541 already tried to force umount this and woken up
542 all waiting network requests, nothing to do */
543 spin_unlock(&cifs_tcp_ses_lock);
545 } else if (tcon->tc_count == 1)
546 tcon->tidStatus = CifsExiting;
547 spin_unlock(&cifs_tcp_ses_lock);
549 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
550 /* cancel_notify_requests(tcon); */
551 if (tcon->ses && tcon->ses->server) {
552 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
553 wake_up_all(&tcon->ses->server->request_q);
554 wake_up_all(&tcon->ses->server->response_q);
555 msleep(1); /* yield */
556 /* we have to kick the requests once more */
557 wake_up_all(&tcon->ses->server->response_q);
564 #ifdef CONFIG_CIFS_STATS2
565 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
572 static int cifs_remount(struct super_block *sb, int *flags, char *data)
575 *flags |= MS_NODIRATIME;
579 static int cifs_drop_inode(struct inode *inode)
581 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
583 /* no serverino => unconditional eviction */
584 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
585 generic_drop_inode(inode);
588 static const struct super_operations cifs_super_ops = {
589 .statfs = cifs_statfs,
590 .alloc_inode = cifs_alloc_inode,
591 .destroy_inode = cifs_destroy_inode,
592 .drop_inode = cifs_drop_inode,
593 .evict_inode = cifs_evict_inode,
594 /* .delete_inode = cifs_delete_inode, */ /* Do not need above
595 function unless later we add lazy close of inodes or unless the
596 kernel forgets to call us with the same number of releases (closes)
598 .show_options = cifs_show_options,
599 .umount_begin = cifs_umount_begin,
600 .remount_fs = cifs_remount,
601 #ifdef CONFIG_CIFS_STATS2
602 .show_stats = cifs_show_stats,
607 * Get root dentry from superblock according to prefix path mount option.
608 * Return dentry with refcount + 1 on success and NULL otherwise.
610 static struct dentry *
611 cifs_get_root(struct smb_vol *vol, struct super_block *sb)
613 struct dentry *dentry;
614 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
615 char *full_path = NULL;
619 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
620 return dget(sb->s_root);
622 full_path = cifs_build_path_to_root(vol, cifs_sb,
623 cifs_sb_master_tcon(cifs_sb), 0);
624 if (full_path == NULL)
625 return ERR_PTR(-ENOMEM);
627 cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
629 sep = CIFS_DIR_SEP(cifs_sb);
630 dentry = dget(sb->s_root);
634 struct inode *dir = d_inode(dentry);
635 struct dentry *child;
639 dentry = ERR_PTR(-ENOENT);
642 if (!S_ISDIR(dir->i_mode)) {
644 dentry = ERR_PTR(-ENOTDIR);
648 /* skip separators */
655 while (*s && *s != sep)
658 child = lookup_one_len_unlocked(p, dentry, s - p);
661 } while (!IS_ERR(dentry));
666 static int cifs_set_super(struct super_block *sb, void *data)
668 struct cifs_mnt_data *mnt_data = data;
669 sb->s_fs_info = mnt_data->cifs_sb;
670 return set_anon_super(sb, NULL);
673 static struct dentry *
674 cifs_do_mount(struct file_system_type *fs_type,
675 int flags, const char *dev_name, void *data)
678 struct super_block *sb;
679 struct cifs_sb_info *cifs_sb;
680 struct smb_vol *volume_info;
681 struct cifs_mnt_data mnt_data;
684 cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
686 volume_info = cifs_get_volume_info((char *)data, dev_name);
687 if (IS_ERR(volume_info))
688 return ERR_CAST(volume_info);
690 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
691 if (cifs_sb == NULL) {
692 root = ERR_PTR(-ENOMEM);
696 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
697 if (cifs_sb->mountdata == NULL) {
698 root = ERR_PTR(-ENOMEM);
702 rc = cifs_setup_cifs_sb(volume_info, cifs_sb);
708 rc = cifs_mount(cifs_sb, volume_info);
710 if (!(flags & MS_SILENT))
711 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
717 mnt_data.vol = volume_info;
718 mnt_data.cifs_sb = cifs_sb;
719 mnt_data.flags = flags;
721 /* BB should we make this contingent on mount parm? */
722 flags |= MS_NODIRATIME | MS_NOATIME;
724 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
727 cifs_umount(cifs_sb);
732 cifs_dbg(FYI, "Use existing superblock\n");
733 cifs_umount(cifs_sb);
735 rc = cifs_read_super(sb);
741 sb->s_flags |= MS_ACTIVE;
744 root = cifs_get_root(volume_info, sb);
748 cifs_dbg(FYI, "dentry root is: %p\n", root);
752 deactivate_locked_super(sb);
754 cifs_cleanup_volume_info(volume_info);
758 kfree(cifs_sb->prepath);
759 kfree(cifs_sb->mountdata);
762 unload_nls(volume_info->local_nls);
767 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
770 struct inode *inode = file_inode(iocb->ki_filp);
772 if (iocb->ki_filp->f_flags & O_DIRECT)
773 return cifs_user_readv(iocb, iter);
775 rc = cifs_revalidate_mapping(inode);
779 return generic_file_read_iter(iocb, iter);
782 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
784 struct inode *inode = file_inode(iocb->ki_filp);
785 struct cifsInodeInfo *cinode = CIFS_I(inode);
789 if (iocb->ki_filp->f_flags & O_DIRECT) {
790 written = cifs_user_writev(iocb, from);
791 if (written > 0 && CIFS_CACHE_READ(cinode)) {
792 cifs_zap_mapping(inode);
794 "Set no oplock for inode=%p after a write operation\n",
801 written = cifs_get_writer(cinode);
805 written = generic_file_write_iter(iocb, from);
807 if (CIFS_CACHE_WRITE(CIFS_I(inode)))
810 rc = filemap_fdatawrite(inode->i_mapping);
812 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
816 cifs_put_writer(cinode);
820 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
823 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
824 * the cached file length
826 if (whence != SEEK_SET && whence != SEEK_CUR) {
828 struct inode *inode = file_inode(file);
831 * We need to be sure that all dirty pages are written and the
832 * server has the newest file length.
834 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
835 inode->i_mapping->nrpages != 0) {
836 rc = filemap_fdatawait(inode->i_mapping);
838 mapping_set_error(inode->i_mapping, rc);
843 * Some applications poll for the file length in this strange
844 * way so we must seek to end on non-oplocked files by
845 * setting the revalidate time to zero.
847 CIFS_I(inode)->time = 0;
849 rc = cifs_revalidate_file_attr(file);
853 return generic_file_llseek(file, offset, whence);
857 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
860 * Note that this is called by vfs setlease with i_lock held to
861 * protect *lease from going away.
863 struct inode *inode = file_inode(file);
864 struct cifsFileInfo *cfile = file->private_data;
866 if (!(S_ISREG(inode->i_mode)))
869 /* Check if file is oplocked if this is request for new lease */
870 if (arg == F_UNLCK ||
871 ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
872 ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
873 return generic_setlease(file, arg, lease, priv);
874 else if (tlink_tcon(cfile->tlink)->local_lease &&
875 !CIFS_CACHE_READ(CIFS_I(inode)))
877 * If the server claims to support oplock on this file, then we
878 * still need to check oplock even if the local_lease mount
879 * option is set, but there are servers which do not support
880 * oplock for which this mount option may be useful if the user
881 * knows that the file won't be changed on the server by anyone
884 return generic_setlease(file, arg, lease, priv);
889 struct file_system_type cifs_fs_type = {
890 .owner = THIS_MODULE,
892 .mount = cifs_do_mount,
893 .kill_sb = cifs_kill_sb,
896 MODULE_ALIAS_FS("cifs");
897 const struct inode_operations cifs_dir_inode_ops = {
898 .create = cifs_create,
899 .atomic_open = cifs_atomic_open,
900 .lookup = cifs_lookup,
901 .getattr = cifs_getattr,
902 .unlink = cifs_unlink,
903 .link = cifs_hardlink,
906 .rename = cifs_rename2,
907 .permission = cifs_permission,
908 .setattr = cifs_setattr,
909 .symlink = cifs_symlink,
911 .listxattr = cifs_listxattr,
914 const struct inode_operations cifs_file_inode_ops = {
915 .setattr = cifs_setattr,
916 .getattr = cifs_getattr,
917 .permission = cifs_permission,
918 .listxattr = cifs_listxattr,
921 const struct inode_operations cifs_symlink_inode_ops = {
922 .get_link = cifs_get_link,
923 .permission = cifs_permission,
924 .listxattr = cifs_listxattr,
927 static int cifs_clone_file_range(struct file *src_file, loff_t off,
928 struct file *dst_file, loff_t destoff, u64 len)
930 struct inode *src_inode = file_inode(src_file);
931 struct inode *target_inode = file_inode(dst_file);
932 struct cifsFileInfo *smb_file_src = src_file->private_data;
933 struct cifsFileInfo *smb_file_target = dst_file->private_data;
934 struct cifs_tcon *target_tcon = tlink_tcon(smb_file_target->tlink);
938 cifs_dbg(FYI, "clone range\n");
942 if (!src_file->private_data || !dst_file->private_data) {
944 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
949 * Note: cifs case is easier than btrfs since server responsible for
950 * checks for proper open modes and file type and if it wants
951 * server could even support copy of range where source = target
953 lock_two_nondirectories(target_inode, src_inode);
956 len = src_inode->i_size - off;
958 cifs_dbg(FYI, "about to flush pages\n");
959 /* should we flush first and last page first */
960 truncate_inode_pages_range(&target_inode->i_data, destoff,
961 PAGE_ALIGN(destoff + len)-1);
963 if (target_tcon->ses->server->ops->duplicate_extents)
964 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
965 smb_file_src, smb_file_target, off, len, destoff);
969 /* force revalidate of size and timestamps of target file now
970 that target is updated on the server */
971 CIFS_I(target_inode)->time = 0;
972 /* although unlocking in the reverse order from locking is not
973 strictly necessary here it is a little cleaner to be consistent */
974 unlock_two_nondirectories(src_inode, target_inode);
980 ssize_t cifs_file_copychunk_range(unsigned int xid,
981 struct file *src_file, loff_t off,
982 struct file *dst_file, loff_t destoff,
983 size_t len, unsigned int flags)
985 struct inode *src_inode = file_inode(src_file);
986 struct inode *target_inode = file_inode(dst_file);
987 struct cifsFileInfo *smb_file_src;
988 struct cifsFileInfo *smb_file_target;
989 struct cifs_tcon *src_tcon;
990 struct cifs_tcon *target_tcon;
993 cifs_dbg(FYI, "copychunk range\n");
995 if (src_inode == target_inode) {
1000 if (!src_file->private_data || !dst_file->private_data) {
1002 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1007 smb_file_target = dst_file->private_data;
1008 smb_file_src = src_file->private_data;
1009 src_tcon = tlink_tcon(smb_file_src->tlink);
1010 target_tcon = tlink_tcon(smb_file_target->tlink);
1012 if (src_tcon->ses != target_tcon->ses) {
1013 cifs_dbg(VFS, "source and target of copy not on same server\n");
1018 * Note: cifs case is easier than btrfs since server responsible for
1019 * checks for proper open modes and file type and if it wants
1020 * server could even support copy of range where source = target
1022 lock_two_nondirectories(target_inode, src_inode);
1024 cifs_dbg(FYI, "about to flush pages\n");
1025 /* should we flush first and last page first */
1026 truncate_inode_pages(&target_inode->i_data, 0);
1028 if (target_tcon->ses->server->ops->copychunk_range)
1029 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1030 smb_file_src, smb_file_target, off, len, destoff);
1034 /* force revalidate of size and timestamps of target file now
1035 * that target is updated on the server
1037 CIFS_I(target_inode)->time = 0;
1038 /* although unlocking in the reverse order from locking is not
1039 * strictly necessary here it is a little cleaner to be consistent
1041 unlock_two_nondirectories(src_inode, target_inode);
1047 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1048 struct file *dst_file, loff_t destoff,
1049 size_t len, unsigned int flags)
1051 unsigned int xid = get_xid();
1054 rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1060 const struct file_operations cifs_file_ops = {
1061 .read_iter = cifs_loose_read_iter,
1062 .write_iter = cifs_file_write_iter,
1064 .release = cifs_close,
1066 .fsync = cifs_fsync,
1067 .flush = cifs_flush,
1068 .mmap = cifs_file_mmap,
1069 .splice_read = generic_file_splice_read,
1070 .llseek = cifs_llseek,
1071 .unlocked_ioctl = cifs_ioctl,
1072 .copy_file_range = cifs_copy_file_range,
1073 .clone_file_range = cifs_clone_file_range,
1074 .setlease = cifs_setlease,
1075 .fallocate = cifs_fallocate,
1078 const struct file_operations cifs_file_strict_ops = {
1079 .read_iter = cifs_strict_readv,
1080 .write_iter = cifs_strict_writev,
1082 .release = cifs_close,
1084 .fsync = cifs_strict_fsync,
1085 .flush = cifs_flush,
1086 .mmap = cifs_file_strict_mmap,
1087 .splice_read = generic_file_splice_read,
1088 .llseek = cifs_llseek,
1089 .unlocked_ioctl = cifs_ioctl,
1090 .copy_file_range = cifs_copy_file_range,
1091 .clone_file_range = cifs_clone_file_range,
1092 .setlease = cifs_setlease,
1093 .fallocate = cifs_fallocate,
1096 const struct file_operations cifs_file_direct_ops = {
1097 /* BB reevaluate whether they can be done with directio, no cache */
1098 .read_iter = cifs_user_readv,
1099 .write_iter = cifs_user_writev,
1101 .release = cifs_close,
1103 .fsync = cifs_fsync,
1104 .flush = cifs_flush,
1105 .mmap = cifs_file_mmap,
1106 .splice_read = generic_file_splice_read,
1107 .unlocked_ioctl = cifs_ioctl,
1108 .copy_file_range = cifs_copy_file_range,
1109 .clone_file_range = cifs_clone_file_range,
1110 .llseek = cifs_llseek,
1111 .setlease = cifs_setlease,
1112 .fallocate = cifs_fallocate,
1115 const struct file_operations cifs_file_nobrl_ops = {
1116 .read_iter = cifs_loose_read_iter,
1117 .write_iter = cifs_file_write_iter,
1119 .release = cifs_close,
1120 .fsync = cifs_fsync,
1121 .flush = cifs_flush,
1122 .mmap = cifs_file_mmap,
1123 .splice_read = generic_file_splice_read,
1124 .llseek = cifs_llseek,
1125 .unlocked_ioctl = cifs_ioctl,
1126 .copy_file_range = cifs_copy_file_range,
1127 .clone_file_range = cifs_clone_file_range,
1128 .setlease = cifs_setlease,
1129 .fallocate = cifs_fallocate,
1132 const struct file_operations cifs_file_strict_nobrl_ops = {
1133 .read_iter = cifs_strict_readv,
1134 .write_iter = cifs_strict_writev,
1136 .release = cifs_close,
1137 .fsync = cifs_strict_fsync,
1138 .flush = cifs_flush,
1139 .mmap = cifs_file_strict_mmap,
1140 .splice_read = generic_file_splice_read,
1141 .llseek = cifs_llseek,
1142 .unlocked_ioctl = cifs_ioctl,
1143 .copy_file_range = cifs_copy_file_range,
1144 .clone_file_range = cifs_clone_file_range,
1145 .setlease = cifs_setlease,
1146 .fallocate = cifs_fallocate,
1149 const struct file_operations cifs_file_direct_nobrl_ops = {
1150 /* BB reevaluate whether they can be done with directio, no cache */
1151 .read_iter = cifs_user_readv,
1152 .write_iter = cifs_user_writev,
1154 .release = cifs_close,
1155 .fsync = cifs_fsync,
1156 .flush = cifs_flush,
1157 .mmap = cifs_file_mmap,
1158 .splice_read = generic_file_splice_read,
1159 .unlocked_ioctl = cifs_ioctl,
1160 .copy_file_range = cifs_copy_file_range,
1161 .clone_file_range = cifs_clone_file_range,
1162 .llseek = cifs_llseek,
1163 .setlease = cifs_setlease,
1164 .fallocate = cifs_fallocate,
1167 const struct file_operations cifs_dir_ops = {
1168 .iterate_shared = cifs_readdir,
1169 .release = cifs_closedir,
1170 .read = generic_read_dir,
1171 .unlocked_ioctl = cifs_ioctl,
1172 .copy_file_range = cifs_copy_file_range,
1173 .clone_file_range = cifs_clone_file_range,
1174 .llseek = generic_file_llseek,
1178 cifs_init_once(void *inode)
1180 struct cifsInodeInfo *cifsi = inode;
1182 inode_init_once(&cifsi->vfs_inode);
1183 init_rwsem(&cifsi->lock_sem);
1187 cifs_init_inodecache(void)
1189 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1190 sizeof(struct cifsInodeInfo),
1191 0, (SLAB_RECLAIM_ACCOUNT|
1192 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1194 if (cifs_inode_cachep == NULL)
1201 cifs_destroy_inodecache(void)
1204 * Make sure all delayed rcu free inodes are flushed before we
1208 kmem_cache_destroy(cifs_inode_cachep);
1212 cifs_init_request_bufs(void)
1214 size_t max_hdr_size = MAX_CIFS_HDR_SIZE;
1215 #ifdef CONFIG_CIFS_SMB2
1217 * SMB2 maximum header size is bigger than CIFS one - no problems to
1218 * allocate some more bytes for CIFS.
1220 max_hdr_size = MAX_SMB2_HDR_SIZE;
1222 if (CIFSMaxBufSize < 8192) {
1223 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1224 Unicode path name has to fit in any SMB/CIFS path based frames */
1225 CIFSMaxBufSize = 8192;
1226 } else if (CIFSMaxBufSize > 1024*127) {
1227 CIFSMaxBufSize = 1024 * 127;
1229 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1232 cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1233 CIFSMaxBufSize, CIFSMaxBufSize);
1235 cifs_req_cachep = kmem_cache_create("cifs_request",
1236 CIFSMaxBufSize + max_hdr_size, 0,
1237 SLAB_HWCACHE_ALIGN, NULL);
1238 if (cifs_req_cachep == NULL)
1241 if (cifs_min_rcv < 1)
1243 else if (cifs_min_rcv > 64) {
1245 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1248 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1251 if (cifs_req_poolp == NULL) {
1252 kmem_cache_destroy(cifs_req_cachep);
1255 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1256 almost all handle based requests (but not write response, nor is it
1257 sufficient for path based requests). A smaller size would have
1258 been more efficient (compacting multiple slab items on one 4k page)
1259 for the case in which debug was on, but this larger size allows
1260 more SMBs to use small buffer alloc and is still much more
1261 efficient to alloc 1 per page off the slab compared to 17K (5page)
1262 alloc of large cifs buffers even when page debugging is on */
1263 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
1264 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1266 if (cifs_sm_req_cachep == NULL) {
1267 mempool_destroy(cifs_req_poolp);
1268 kmem_cache_destroy(cifs_req_cachep);
1272 if (cifs_min_small < 2)
1274 else if (cifs_min_small > 256) {
1275 cifs_min_small = 256;
1276 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1279 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1280 cifs_sm_req_cachep);
1282 if (cifs_sm_req_poolp == NULL) {
1283 mempool_destroy(cifs_req_poolp);
1284 kmem_cache_destroy(cifs_req_cachep);
1285 kmem_cache_destroy(cifs_sm_req_cachep);
1293 cifs_destroy_request_bufs(void)
1295 mempool_destroy(cifs_req_poolp);
1296 kmem_cache_destroy(cifs_req_cachep);
1297 mempool_destroy(cifs_sm_req_poolp);
1298 kmem_cache_destroy(cifs_sm_req_cachep);
1302 cifs_init_mids(void)
1304 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1305 sizeof(struct mid_q_entry), 0,
1306 SLAB_HWCACHE_ALIGN, NULL);
1307 if (cifs_mid_cachep == NULL)
1310 /* 3 is a reasonable minimum number of simultaneous operations */
1311 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1312 if (cifs_mid_poolp == NULL) {
1313 kmem_cache_destroy(cifs_mid_cachep);
1321 cifs_destroy_mids(void)
1323 mempool_destroy(cifs_mid_poolp);
1324 kmem_cache_destroy(cifs_mid_cachep);
1332 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1333 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1334 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1335 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1336 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1338 * Initialize Global counters
1340 atomic_set(&sesInfoAllocCount, 0);
1341 atomic_set(&tconInfoAllocCount, 0);
1342 atomic_set(&tcpSesAllocCount, 0);
1343 atomic_set(&tcpSesReconnectCount, 0);
1344 atomic_set(&tconInfoReconnectCount, 0);
1346 atomic_set(&bufAllocCount, 0);
1347 atomic_set(&smBufAllocCount, 0);
1348 #ifdef CONFIG_CIFS_STATS2
1349 atomic_set(&totBufAllocCount, 0);
1350 atomic_set(&totSmBufAllocCount, 0);
1351 #endif /* CONFIG_CIFS_STATS2 */
1353 atomic_set(&midCount, 0);
1354 GlobalCurrentXid = 0;
1355 GlobalTotalActiveXid = 0;
1356 GlobalMaxActiveXid = 0;
1357 spin_lock_init(&cifs_tcp_ses_lock);
1358 spin_lock_init(&GlobalMid_Lock);
1360 get_random_bytes(&cifs_lock_secret, sizeof(cifs_lock_secret));
1362 if (cifs_max_pending < 2) {
1363 cifs_max_pending = 2;
1364 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1365 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1366 cifs_max_pending = CIFS_MAX_REQ;
1367 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1371 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1374 goto out_clean_proc;
1377 rc = cifs_fscache_register();
1379 goto out_destroy_wq;
1381 rc = cifs_init_inodecache();
1383 goto out_unreg_fscache;
1385 rc = cifs_init_mids();
1387 goto out_destroy_inodecache;
1389 rc = cifs_init_request_bufs();
1391 goto out_destroy_mids;
1393 #ifdef CONFIG_CIFS_UPCALL
1394 rc = init_cifs_spnego();
1396 goto out_destroy_request_bufs;
1397 #endif /* CONFIG_CIFS_UPCALL */
1399 #ifdef CONFIG_CIFS_ACL
1400 rc = init_cifs_idmap();
1402 goto out_register_key_type;
1403 #endif /* CONFIG_CIFS_ACL */
1405 rc = register_filesystem(&cifs_fs_type);
1407 goto out_init_cifs_idmap;
1411 out_init_cifs_idmap:
1412 #ifdef CONFIG_CIFS_ACL
1414 out_register_key_type:
1416 #ifdef CONFIG_CIFS_UPCALL
1418 out_destroy_request_bufs:
1420 cifs_destroy_request_bufs();
1422 cifs_destroy_mids();
1423 out_destroy_inodecache:
1424 cifs_destroy_inodecache();
1426 cifs_fscache_unregister();
1428 destroy_workqueue(cifsiod_wq);
1437 cifs_dbg(NOISY, "exit_cifs\n");
1438 unregister_filesystem(&cifs_fs_type);
1439 cifs_dfs_release_automount_timer();
1440 #ifdef CONFIG_CIFS_ACL
1443 #ifdef CONFIG_CIFS_UPCALL
1444 unregister_key_type(&cifs_spnego_key_type);
1446 cifs_destroy_request_bufs();
1447 cifs_destroy_mids();
1448 cifs_destroy_inodecache();
1449 cifs_fscache_unregister();
1450 destroy_workqueue(cifsiod_wq);
1454 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1455 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1457 ("VFS to access servers complying with the SNIA CIFS Specification "
1458 "e.g. Samba and Windows");
1459 MODULE_VERSION(CIFS_VERSION);
1460 MODULE_SOFTDEP("pre: arc4");
1461 MODULE_SOFTDEP("pre: des");
1462 MODULE_SOFTDEP("pre: ecb");
1463 MODULE_SOFTDEP("pre: hmac");
1464 MODULE_SOFTDEP("pre: md4");
1465 MODULE_SOFTDEP("pre: md5");
1466 MODULE_SOFTDEP("pre: nls");
1467 #ifdef CONFIG_CIFS_SMB2
1468 MODULE_SOFTDEP("pre: aes");
1469 MODULE_SOFTDEP("pre: cmac");
1470 MODULE_SOFTDEP("pre: sha256");
1471 MODULE_SOFTDEP("pre: aead2");
1472 MODULE_SOFTDEP("pre: ccm");
1473 #endif /* CONFIG_CIFS_SMB2 */
1474 module_init(init_cifs)
1475 module_exit(exit_cifs)