fs/cifs/cifsfs.c

   1 /*
   2  *   fs/cifs/cifsfs.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2008
   5  *   Author(s): Steve French (sfrench@us.ibm.com)
   6  *
   7  *   Common Internet FileSystem (CIFS) client
   8  *
   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.
  13  *
  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.
  18  *
  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
  22  */
  23
  24 /* Note that BB means BUGBUG (ie something to fix eventually) */
  25
  26 #include <linux/module.h>
  27 #include <linux/fs.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/uuid.h>
  41 #include <linux/xattr.h>
  42 #include <net/ipv6.h>
  43 #include "cifsfs.h"
  44 #include "cifspdu.h"
  45 #define DECLARE_GLOBALS_HERE
  46 #include "cifsglob.h"
  47 #include "cifsproto.h"
  48 #include "cifs_debug.h"
  49 #include "cifs_fs_sb.h"
  50 #include <linux/mm.h>
  51 #include <linux/key-type.h>
  52 #include "cifs_spnego.h"
  53 #include "fscache.h"
  54 #include "smb2pdu.h"
  55 #ifdef CONFIG_CIFS_DFS_UPCALL
  56 #include "dfs_cache.h"
  57 #endif
  58
  59 /*
  60  * DOS dates from 1980/1/1 through 2107/12/31
  61  * Protocol specifications indicate the range should be to 119, which
  62  * limits maximum year to 2099. But this range has not been checked.
  63  */
  64 #define SMB_DATE_MAX (127<<9 | 12<<5 | 31)
  65 #define SMB_DATE_MIN (0<<9 | 1<<5 | 1)
  66 #define SMB_TIME_MAX (23<<11 | 59<<5 | 29)
  67
  68 int cifsFYI = 0;
  69 bool traceSMB;
  70 bool enable_oplocks = true;
  71 bool linuxExtEnabled = true;
  72 bool lookupCacheEnabled = true;
  73 bool disable_legacy_dialects; /* false by default */
  74 unsigned int global_secflags = CIFSSEC_DEF;
  75 /* unsigned int ntlmv2_support = 0; */
  76 unsigned int sign_CIFS_PDUs = 1;
  77 static const struct super_operations cifs_super_ops;
  78 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
  79 module_param(CIFSMaxBufSize, uint, 0444);
  80 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header) "
  81                                  "for CIFS requests. "
  82                                  "Default: 16384 Range: 8192 to 130048");
  83 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
  84 module_param(cifs_min_rcv, uint, 0444);
  85 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
  86                                 "1 to 64");
  87 unsigned int cifs_min_small = 30;
  88 module_param(cifs_min_small, uint, 0444);
  89 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
  90                                  "Range: 2 to 256");
  91 unsigned int cifs_max_pending = CIFS_MAX_REQ;
  92 module_param(cifs_max_pending, uint, 0444);
  93 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server for "
  94                                    "CIFS/SMB1 dialect (N/A for SMB3) "
  95                                    "Default: 32767 Range: 2 to 32767.");
  96 #ifdef CONFIG_CIFS_STATS2
  97 unsigned int slow_rsp_threshold = 1;
  98 module_param(slow_rsp_threshold, uint, 0644);
  99 MODULE_PARM_DESC(slow_rsp_threshold, "Amount of time (in seconds) to wait "
 100                                    "before logging that a response is delayed. "
 101                                    "Default: 1 (if set to 0 disables msg).");
 102 #endif /* STATS2 */
 103
 104 module_param(enable_oplocks, bool, 0644);
 105 MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
 106
 107 module_param(disable_legacy_dialects, bool, 0644);
 108 MODULE_PARM_DESC(disable_legacy_dialects, "To improve security it may be "
 109                                   "helpful to restrict the ability to "
 110                                   "override the default dialects (SMB2.1, "
 111                                   "SMB3 and SMB3.02) on mount with old "
 112                                   "dialects (CIFS/SMB1 and SMB2) since "
 113                                   "vers=1.0 (CIFS/SMB1) and vers=2.0 are weaker"
 114                                   " and less secure. Default: n/N/0");
 115
 116 extern mempool_t *cifs_sm_req_poolp;
 117 extern mempool_t *cifs_req_poolp;
 118 extern mempool_t *cifs_mid_poolp;
 119
 120 struct workqueue_struct *cifsiod_wq;
 121 struct workqueue_struct *decrypt_wq;
 122 struct workqueue_struct *cifsoplockd_wq;
 123 __u32 cifs_lock_secret;
 124
 125 /*
 126  * Bumps refcount for cifs super block.
 127  * Note that it should be only called if a referece to VFS super block is
 128  * already held, e.g. in open-type syscalls context. Otherwise it can race with
 129  * atomic_dec_and_test in deactivate_locked_super.
 130  */
 131 void
 132 cifs_sb_active(struct super_block *sb)
 133 {
 134         struct cifs_sb_info *server = CIFS_SB(sb);
 135
 136         if (atomic_inc_return(&server->active) == 1)
 137                 atomic_inc(&sb->s_active);
 138 }
 139
 140 void
 141 cifs_sb_deactive(struct super_block *sb)
 142 {
 143         struct cifs_sb_info *server = CIFS_SB(sb);
 144
 145         if (atomic_dec_and_test(&server->active))
 146                 deactivate_super(sb);
 147 }
 148
 149 static int
 150 cifs_read_super(struct super_block *sb)
 151 {
 152         struct inode *inode;
 153         struct cifs_sb_info *cifs_sb;
 154         struct cifs_tcon *tcon;
 155         struct timespec64 ts;
 156         int rc = 0;
 157
 158         cifs_sb = CIFS_SB(sb);
 159         tcon = cifs_sb_master_tcon(cifs_sb);
 160
 161         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
 162                 sb->s_flags |= SB_POSIXACL;
 163
 164         if (tcon->snapshot_time)
 165                 sb->s_flags |= SB_RDONLY;
 166
 167         if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
 168                 sb->s_maxbytes = MAX_LFS_FILESIZE;
 169         else
 170                 sb->s_maxbytes = MAX_NON_LFS;
 171
 172         /*
 173          * Some very old servers like DOS and OS/2 used 2 second granularity
 174          * (while all current servers use 100ns granularity - see MS-DTYP)
 175          * but 1 second is the maximum allowed granularity for the VFS
 176          * so for old servers set time granularity to 1 second while for
 177          * everything else (current servers) set it to 100ns.
 178          */
 179         if ((tcon->ses->server->vals->protocol_id == SMB10_PROT_ID) &&
 180             ((tcon->ses->capabilities &
 181               tcon->ses->server->vals->cap_nt_find) == 0) &&
 182             !tcon->unix_ext) {
 183                 sb->s_time_gran = 1000000000; /* 1 second is max allowed gran */
 184                 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MIN), 0, 0);
 185                 sb->s_time_min = ts.tv_sec;
 186                 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MAX),
 187                                     cpu_to_le16(SMB_TIME_MAX), 0);
 188                 sb->s_time_max = ts.tv_sec;
 189         } else {
 190                 /*
 191                  * Almost every server, including all SMB2+, uses DCE TIME
 192                  * ie 100 nanosecond units, since 1601.  See MS-DTYP and MS-FSCC
 193                  */
 194                 sb->s_time_gran = 100;
 195                 ts = cifs_NTtimeToUnix(0);
 196                 sb->s_time_min = ts.tv_sec;
 197                 ts = cifs_NTtimeToUnix(cpu_to_le64(S64_MAX));
 198                 sb->s_time_max = ts.tv_sec;
 199         }
 200
 201         sb->s_magic = CIFS_MAGIC_NUMBER;
 202         sb->s_op = &cifs_super_ops;
 203         sb->s_xattr = cifs_xattr_handlers;
 204         rc = super_setup_bdi(sb);
 205         if (rc)
 206                 goto out_no_root;
 207         /* tune readahead according to rsize */
 208         sb->s_bdi->ra_pages = cifs_sb->rsize / PAGE_SIZE;
 209
 210         sb->s_blocksize = CIFS_MAX_MSGSIZE;
 211         sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
 212         inode = cifs_root_iget(sb);
 213
 214         if (IS_ERR(inode)) {
 215                 rc = PTR_ERR(inode);
 216                 goto out_no_root;
 217         }
 218
 219         if (tcon->nocase)
 220                 sb->s_d_op = &cifs_ci_dentry_ops;
 221         else
 222                 sb->s_d_op = &cifs_dentry_ops;
 223
 224         sb->s_root = d_make_root(inode);
 225         if (!sb->s_root) {
 226                 rc = -ENOMEM;
 227                 goto out_no_root;
 228         }
 229
 230 #ifdef CONFIG_CIFS_NFSD_EXPORT
 231         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 232                 cifs_dbg(FYI, "export ops supported\n");
 233                 sb->s_export_op = &cifs_export_ops;
 234         }
 235 #endif /* CONFIG_CIFS_NFSD_EXPORT */
 236
 237         return 0;
 238
 239 out_no_root:
 240         cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
 241         return rc;
 242 }
 243
 244 static void cifs_kill_sb(struct super_block *sb)
 245 {
 246         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 247         kill_anon_super(sb);
 248         cifs_umount(cifs_sb);
 249 }
 250
 251 static int
 252 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
 253 {
 254         struct super_block *sb = dentry->d_sb;
 255         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 256         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 257         struct TCP_Server_Info *server = tcon->ses->server;
 258         unsigned int xid;
 259         int rc = 0;
 260
 261         xid = get_xid();
 262
 263         if (le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength) > 0)
 264                 buf->f_namelen =
 265                        le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength);
 266         else
 267                 buf->f_namelen = PATH_MAX;
 268
 269         buf->f_fsid.val[0] = tcon->vol_serial_number;
 270         /* are using part of create time for more randomness, see man statfs */
 271         buf->f_fsid.val[1] =  (int)le64_to_cpu(tcon->vol_create_time);
 272
 273         buf->f_files = 0;       /* undefined */
 274         buf->f_ffree = 0;       /* unlimited */
 275
 276         if (server->ops->queryfs)
 277                 rc = server->ops->queryfs(xid, tcon, buf);
 278
 279         free_xid(xid);
 280         return 0;
 281 }
 282
 283 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
 284 {
 285         struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
 286         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 287         struct TCP_Server_Info *server = tcon->ses->server;
 288
 289         if (server->ops->fallocate)
 290                 return server->ops->fallocate(file, tcon, mode, off, len);
 291
 292         return -EOPNOTSUPP;
 293 }
 294
 295 static int cifs_permission(struct inode *inode, int mask)
 296 {
 297         struct cifs_sb_info *cifs_sb;
 298
 299         cifs_sb = CIFS_SB(inode->i_sb);
 300
 301         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
 302                 if ((mask & MAY_EXEC) && !execute_ok(inode))
 303                         return -EACCES;
 304                 else
 305                         return 0;
 306         } else /* file mode might have been restricted at mount time
 307                 on the client (above and beyond ACL on servers) for
 308                 servers which do not support setting and viewing mode bits,
 309                 so allowing client to check permissions is useful */
 310                 return generic_permission(inode, mask);
 311 }
 312
 313 static struct kmem_cache *cifs_inode_cachep;
 314 static struct kmem_cache *cifs_req_cachep;
 315 static struct kmem_cache *cifs_mid_cachep;
 316 static struct kmem_cache *cifs_sm_req_cachep;
 317 mempool_t *cifs_sm_req_poolp;
 318 mempool_t *cifs_req_poolp;
 319 mempool_t *cifs_mid_poolp;
 320
 321 static struct inode *
 322 cifs_alloc_inode(struct super_block *sb)
 323 {
 324         struct cifsInodeInfo *cifs_inode;
 325         cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
 326         if (!cifs_inode)
 327                 return NULL;
 328         cifs_inode->cifsAttrs = 0x20;   /* default */
 329         cifs_inode->time = 0;
 330         /*
 331          * Until the file is open and we have gotten oplock info back from the
 332          * server, can not assume caching of file data or metadata.
 333          */
 334         cifs_set_oplock_level(cifs_inode, 0);
 335         cifs_inode->flags = 0;
 336         spin_lock_init(&cifs_inode->writers_lock);
 337         cifs_inode->writers = 0;
 338         cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
 339         cifs_inode->server_eof = 0;
 340         cifs_inode->uniqueid = 0;
 341         cifs_inode->createtime = 0;
 342         cifs_inode->epoch = 0;
 343         spin_lock_init(&cifs_inode->open_file_lock);
 344         generate_random_uuid(cifs_inode->lease_key);
 345
 346         /*
 347          * Can not set i_flags here - they get immediately overwritten to zero
 348          * by the VFS.
 349          */
 350         /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
 351         INIT_LIST_HEAD(&cifs_inode->openFileList);
 352         INIT_LIST_HEAD(&cifs_inode->llist);
 353         return &cifs_inode->vfs_inode;
 354 }
 355
 356 static void
 357 cifs_free_inode(struct inode *inode)
 358 {
 359         kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
 360 }
 361
 362 static void
 363 cifs_evict_inode(struct inode *inode)
 364 {
 365         truncate_inode_pages_final(&inode->i_data);
 366         clear_inode(inode);
 367         cifs_fscache_release_inode_cookie(inode);
 368 }
 369
 370 static void
 371 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
 372 {
 373         struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
 374         struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
 375
 376         seq_puts(s, ",addr=");
 377
 378         switch (server->dstaddr.ss_family) {
 379         case AF_INET:
 380                 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
 381                 break;
 382         case AF_INET6:
 383                 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
 384                 if (sa6->sin6_scope_id)
 385                         seq_printf(s, "%%%u", sa6->sin6_scope_id);
 386                 break;
 387         default:
 388                 seq_puts(s, "(unknown)");
 389         }
 390         if (server->rdma)
 391                 seq_puts(s, ",rdma");
 392 }
 393
 394 static void
 395 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
 396 {
 397         if (ses->sectype == Unspecified) {
 398                 if (ses->user_name == NULL)
 399                         seq_puts(s, ",sec=none");
 400                 return;
 401         }
 402
 403         seq_puts(s, ",sec=");
 404
 405         switch (ses->sectype) {
 406         case LANMAN:
 407                 seq_puts(s, "lanman");
 408                 break;
 409         case NTLMv2:
 410                 seq_puts(s, "ntlmv2");
 411                 break;
 412         case NTLM:
 413                 seq_puts(s, "ntlm");
 414                 break;
 415         case Kerberos:
 416                 seq_printf(s, "krb5,cruid=%u", from_kuid_munged(&init_user_ns,ses->cred_uid));
 417                 break;
 418         case RawNTLMSSP:
 419                 seq_puts(s, "ntlmssp");
 420                 break;
 421         default:
 422                 /* shouldn't ever happen */
 423                 seq_puts(s, "unknown");
 424                 break;
 425         }
 426
 427         if (ses->sign)
 428                 seq_puts(s, "i");
 429 }
 430
 431 static void
 432 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
 433 {
 434         seq_puts(s, ",cache=");
 435
 436         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 437                 seq_puts(s, "strict");
 438         else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
 439                 seq_puts(s, "none");
 440         else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
 441                 seq_puts(s, "singleclient"); /* assume only one client access */
 442         else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE)
 443                 seq_puts(s, "ro"); /* read only caching assumed */
 444         else
 445                 seq_puts(s, "loose");
 446 }
 447
 448 static void
 449 cifs_show_nls(struct seq_file *s, struct nls_table *cur)
 450 {
 451         struct nls_table *def;
 452
 453         /* Display iocharset= option if it's not default charset */
 454         def = load_nls_default();
 455         if (def != cur)
 456                 seq_printf(s, ",iocharset=%s", cur->charset);
 457         unload_nls(def);
 458 }
 459
 460 /*
 461  * cifs_show_options() is for displaying mount options in /proc/mounts.
 462  * Not all settable options are displayed but most of the important
 463  * ones are.
 464  */
 465 static int
 466 cifs_show_options(struct seq_file *s, struct dentry *root)
 467 {
 468         struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
 469         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 470         struct sockaddr *srcaddr;
 471         srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
 472
 473         seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
 474         cifs_show_security(s, tcon->ses);
 475         cifs_show_cache_flavor(s, cifs_sb);
 476
 477         if (tcon->no_lease)
 478                 seq_puts(s, ",nolease");
 479         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
 480                 seq_puts(s, ",multiuser");
 481         else if (tcon->ses->user_name)
 482                 seq_show_option(s, "username", tcon->ses->user_name);
 483
 484         if (tcon->ses->domainName && tcon->ses->domainName[0] != 0)
 485                 seq_show_option(s, "domain", tcon->ses->domainName);
 486
 487         if (srcaddr->sa_family != AF_UNSPEC) {
 488                 struct sockaddr_in *saddr4;
 489                 struct sockaddr_in6 *saddr6;
 490                 saddr4 = (struct sockaddr_in *)srcaddr;
 491                 saddr6 = (struct sockaddr_in6 *)srcaddr;
 492                 if (srcaddr->sa_family == AF_INET6)
 493                         seq_printf(s, ",srcaddr=%pI6c",
 494                                    &saddr6->sin6_addr);
 495                 else if (srcaddr->sa_family == AF_INET)
 496                         seq_printf(s, ",srcaddr=%pI4",
 497                                    &saddr4->sin_addr.s_addr);
 498                 else
 499                         seq_printf(s, ",srcaddr=BAD-AF:%i",
 500                                    (int)(srcaddr->sa_family));
 501         }
 502
 503         seq_printf(s, ",uid=%u",
 504                    from_kuid_munged(&init_user_ns, cifs_sb->mnt_uid));
 505         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
 506                 seq_puts(s, ",forceuid");
 507         else
 508                 seq_puts(s, ",noforceuid");
 509
 510         seq_printf(s, ",gid=%u",
 511                    from_kgid_munged(&init_user_ns, cifs_sb->mnt_gid));
 512         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
 513                 seq_puts(s, ",forcegid");
 514         else
 515                 seq_puts(s, ",noforcegid");
 516
 517         cifs_show_address(s, tcon->ses->server);
 518
 519         if (!tcon->unix_ext)
 520                 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
 521                                            cifs_sb->mnt_file_mode,
 522                                            cifs_sb->mnt_dir_mode);
 523
 524         cifs_show_nls(s, cifs_sb->local_nls);
 525
 526         if (tcon->seal)
 527                 seq_puts(s, ",seal");
 528         if (tcon->nocase)
 529                 seq_puts(s, ",nocase");
 530         if (tcon->local_lease)
 531                 seq_puts(s, ",locallease");
 532         if (tcon->retry)
 533                 seq_puts(s, ",hard");
 534         else
 535                 seq_puts(s, ",soft");
 536         if (tcon->use_persistent)
 537                 seq_puts(s, ",persistenthandles");
 538         else if (tcon->use_resilient)
 539                 seq_puts(s, ",resilienthandles");
 540         if (tcon->posix_extensions)
 541                 seq_puts(s, ",posix");
 542         else if (tcon->unix_ext)
 543                 seq_puts(s, ",unix");
 544         else
 545                 seq_puts(s, ",nounix");
 546         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
 547                 seq_puts(s, ",nodfs");
 548         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
 549                 seq_puts(s, ",posixpaths");
 550         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
 551                 seq_puts(s, ",setuids");
 552         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
 553                 seq_puts(s, ",idsfromsid");
 554         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 555                 seq_puts(s, ",serverino");
 556         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
 557                 seq_puts(s, ",rwpidforward");
 558         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
 559                 seq_puts(s, ",forcemand");
 560         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 561                 seq_puts(s, ",nouser_xattr");
 562         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
 563                 seq_puts(s, ",mapchars");
 564         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
 565                 seq_puts(s, ",mapposix");
 566         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
 567                 seq_puts(s, ",sfu");
 568         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 569                 seq_puts(s, ",nobrl");
 570         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_HANDLE_CACHE)
 571                 seq_puts(s, ",nohandlecache");
 572         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)
 573                 seq_puts(s, ",modefromsid");
 574         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
 575                 seq_puts(s, ",cifsacl");
 576         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
 577                 seq_puts(s, ",dynperm");
 578         if (root->d_sb->s_flags & SB_POSIXACL)
 579                 seq_puts(s, ",acl");
 580         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
 581                 seq_puts(s, ",mfsymlinks");
 582         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
 583                 seq_puts(s, ",fsc");
 584         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
 585                 seq_puts(s, ",nostrictsync");
 586         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
 587                 seq_puts(s, ",noperm");
 588         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
 589                 seq_printf(s, ",backupuid=%u",
 590                            from_kuid_munged(&init_user_ns,
 591                                             cifs_sb->mnt_backupuid));
 592         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
 593                 seq_printf(s, ",backupgid=%u",
 594                            from_kgid_munged(&init_user_ns,
 595                                             cifs_sb->mnt_backupgid));
 596
 597         seq_printf(s, ",rsize=%u", cifs_sb->rsize);
 598         seq_printf(s, ",wsize=%u", cifs_sb->wsize);
 599         seq_printf(s, ",bsize=%u", cifs_sb->bsize);
 600         if (tcon->ses->server->min_offload)
 601                 seq_printf(s, ",esize=%u", tcon->ses->server->min_offload);
 602         seq_printf(s, ",echo_interval=%lu",
 603                         tcon->ses->server->echo_interval / HZ);
 604
 605         /* Only display max_credits if it was overridden on mount */
 606         if (tcon->ses->server->max_credits != SMB2_MAX_CREDITS_AVAILABLE)
 607                 seq_printf(s, ",max_credits=%u", tcon->ses->server->max_credits);
 608
 609         if (tcon->snapshot_time)
 610                 seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);
 611         if (tcon->handle_timeout)
 612                 seq_printf(s, ",handletimeout=%u", tcon->handle_timeout);
 613         /* convert actimeo and display it in seconds */
 614         seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
 615
 616         return 0;
 617 }
 618
 619 static void cifs_umount_begin(struct super_block *sb)
 620 {
 621         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 622         struct cifs_tcon *tcon;
 623
 624         if (cifs_sb == NULL)
 625                 return;
 626
 627         tcon = cifs_sb_master_tcon(cifs_sb);
 628
 629         spin_lock(&cifs_tcp_ses_lock);
 630         if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
 631                 /* we have other mounts to same share or we have
 632                    already tried to force umount this and woken up
 633                    all waiting network requests, nothing to do */
 634                 spin_unlock(&cifs_tcp_ses_lock);
 635                 return;
 636         } else if (tcon->tc_count == 1)
 637                 tcon->tidStatus = CifsExiting;
 638         spin_unlock(&cifs_tcp_ses_lock);
 639
 640         /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
 641         /* cancel_notify_requests(tcon); */
 642         if (tcon->ses && tcon->ses->server) {
 643                 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
 644                 wake_up_all(&tcon->ses->server->request_q);
 645                 wake_up_all(&tcon->ses->server->response_q);
 646                 msleep(1); /* yield */
 647                 /* we have to kick the requests once more */
 648                 wake_up_all(&tcon->ses->server->response_q);
 649                 msleep(1);
 650         }
 651
 652         return;
 653 }
 654
 655 #ifdef CONFIG_CIFS_STATS2
 656 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
 657 {
 658         /* BB FIXME */
 659         return 0;
 660 }
 661 #endif
 662
 663 static int cifs_remount(struct super_block *sb, int *flags, char *data)
 664 {
 665         sync_filesystem(sb);
 666         *flags |= SB_NODIRATIME;
 667         return 0;
 668 }
 669
 670 static int cifs_drop_inode(struct inode *inode)
 671 {
 672         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 673
 674         /* no serverino => unconditional eviction */
 675         return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
 676                 generic_drop_inode(inode);
 677 }
 678
 679 static const struct super_operations cifs_super_ops = {
 680         .statfs = cifs_statfs,
 681         .alloc_inode = cifs_alloc_inode,
 682         .free_inode = cifs_free_inode,
 683         .drop_inode     = cifs_drop_inode,
 684         .evict_inode    = cifs_evict_inode,
 685 /*      .delete_inode   = cifs_delete_inode,  */  /* Do not need above
 686         function unless later we add lazy close of inodes or unless the
 687         kernel forgets to call us with the same number of releases (closes)
 688         as opens */
 689         .show_options = cifs_show_options,
 690         .umount_begin   = cifs_umount_begin,
 691         .remount_fs = cifs_remount,
 692 #ifdef CONFIG_CIFS_STATS2
 693         .show_stats = cifs_show_stats,
 694 #endif
 695 };
 696
 697 /*
 698  * Get root dentry from superblock according to prefix path mount option.
 699  * Return dentry with refcount + 1 on success and NULL otherwise.
 700  */
 701 static struct dentry *
 702 cifs_get_root(struct smb_vol *vol, struct super_block *sb)
 703 {
 704         struct dentry *dentry;
 705         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 706         char *full_path = NULL;
 707         char *s, *p;
 708         char sep;
 709
 710         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
 711                 return dget(sb->s_root);
 712
 713         full_path = cifs_build_path_to_root(vol, cifs_sb,
 714                                 cifs_sb_master_tcon(cifs_sb), 0);
 715         if (full_path == NULL)
 716                 return ERR_PTR(-ENOMEM);
 717
 718         cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
 719
 720         sep = CIFS_DIR_SEP(cifs_sb);
 721         dentry = dget(sb->s_root);
 722         p = s = full_path;
 723
 724         do {
 725                 struct inode *dir = d_inode(dentry);
 726                 struct dentry *child;
 727
 728                 if (!dir) {
 729                         dput(dentry);
 730                         dentry = ERR_PTR(-ENOENT);
 731                         break;
 732                 }
 733                 if (!S_ISDIR(dir->i_mode)) {
 734                         dput(dentry);
 735                         dentry = ERR_PTR(-ENOTDIR);
 736                         break;
 737                 }
 738
 739                 /* skip separators */
 740                 while (*s == sep)
 741                         s++;
 742                 if (!*s)
 743                         break;
 744                 p = s++;
 745                 /* next separator */
 746                 while (*s && *s != sep)
 747                         s++;
 748
 749                 child = lookup_one_len_unlocked(p, dentry, s - p);
 750                 dput(dentry);
 751                 dentry = child;
 752         } while (!IS_ERR(dentry));
 753         kfree(full_path);
 754         return dentry;
 755 }
 756
 757 static int cifs_set_super(struct super_block *sb, void *data)
 758 {
 759         struct cifs_mnt_data *mnt_data = data;
 760         sb->s_fs_info = mnt_data->cifs_sb;
 761         return set_anon_super(sb, NULL);
 762 }
 763
 764 static struct dentry *
 765 cifs_smb3_do_mount(struct file_system_type *fs_type,
 766               int flags, const char *dev_name, void *data, bool is_smb3)
 767 {
 768         int rc;
 769         struct super_block *sb;
 770         struct cifs_sb_info *cifs_sb;
 771         struct smb_vol *volume_info;
 772         struct cifs_mnt_data mnt_data;
 773         struct dentry *root;
 774
 775         /*
 776          * Prints in Kernel / CIFS log the attempted mount operation
 777          *      If CIFS_DEBUG && cifs_FYI
 778          */
 779         if (cifsFYI)
 780                 cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
 781         else
 782                 cifs_info("Attempting to mount %s\n", dev_name);
 783
 784         volume_info = cifs_get_volume_info((char *)data, dev_name, is_smb3);
 785         if (IS_ERR(volume_info))
 786                 return ERR_CAST(volume_info);
 787
 788         cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
 789         if (cifs_sb == NULL) {
 790                 root = ERR_PTR(-ENOMEM);
 791                 goto out_nls;
 792         }
 793
 794         cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
 795         if (cifs_sb->mountdata == NULL) {
 796                 root = ERR_PTR(-ENOMEM);
 797                 goto out_free;
 798         }
 799
 800         rc = cifs_setup_cifs_sb(volume_info, cifs_sb);
 801         if (rc) {
 802                 root = ERR_PTR(rc);
 803                 goto out_free;
 804         }
 805
 806         rc = cifs_mount(cifs_sb, volume_info);
 807         if (rc) {
 808                 if (!(flags & SB_SILENT))
 809                         cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
 810                                  rc);
 811                 root = ERR_PTR(rc);
 812                 goto out_free;
 813         }
 814
 815         mnt_data.vol = volume_info;
 816         mnt_data.cifs_sb = cifs_sb;
 817         mnt_data.flags = flags;
 818
 819         /* BB should we make this contingent on mount parm? */
 820         flags |= SB_NODIRATIME | SB_NOATIME;
 821
 822         sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
 823         if (IS_ERR(sb)) {
 824                 root = ERR_CAST(sb);
 825                 cifs_umount(cifs_sb);
 826                 goto out;
 827         }
 828
 829         if (sb->s_root) {
 830                 cifs_dbg(FYI, "Use existing superblock\n");
 831                 cifs_umount(cifs_sb);
 832         } else {
 833                 rc = cifs_read_super(sb);
 834                 if (rc) {
 835                         root = ERR_PTR(rc);
 836                         goto out_super;
 837                 }
 838
 839                 sb->s_flags |= SB_ACTIVE;
 840         }
 841
 842         root = cifs_get_root(volume_info, sb);
 843         if (IS_ERR(root))
 844                 goto out_super;
 845
 846         cifs_dbg(FYI, "dentry root is: %p\n", root);
 847         goto out;
 848
 849 out_super:
 850         deactivate_locked_super(sb);
 851 out:
 852         cifs_cleanup_volume_info(volume_info);
 853         return root;
 854
 855 out_free:
 856         kfree(cifs_sb->prepath);
 857         kfree(cifs_sb->mountdata);
 858         kfree(cifs_sb);
 859 out_nls:
 860         unload_nls(volume_info->local_nls);
 861         goto out;
 862 }
 863
 864 static struct dentry *
 865 smb3_do_mount(struct file_system_type *fs_type,
 866               int flags, const char *dev_name, void *data)
 867 {
 868         return cifs_smb3_do_mount(fs_type, flags, dev_name, data, true);
 869 }
 870
 871 static struct dentry *
 872 cifs_do_mount(struct file_system_type *fs_type,
 873               int flags, const char *dev_name, void *data)
 874 {
 875         return cifs_smb3_do_mount(fs_type, flags, dev_name, data, false);
 876 }
 877
 878 static ssize_t
 879 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
 880 {
 881         ssize_t rc;
 882         struct inode *inode = file_inode(iocb->ki_filp);
 883
 884         if (iocb->ki_filp->f_flags & O_DIRECT)
 885                 return cifs_user_readv(iocb, iter);
 886
 887         rc = cifs_revalidate_mapping(inode);
 888         if (rc)
 889                 return rc;
 890
 891         return generic_file_read_iter(iocb, iter);
 892 }
 893
 894 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 895 {
 896         struct inode *inode = file_inode(iocb->ki_filp);
 897         struct cifsInodeInfo *cinode = CIFS_I(inode);
 898         ssize_t written;
 899         int rc;
 900
 901         if (iocb->ki_filp->f_flags & O_DIRECT) {
 902                 written = cifs_user_writev(iocb, from);
 903                 if (written > 0 && CIFS_CACHE_READ(cinode)) {
 904                         cifs_zap_mapping(inode);
 905                         cifs_dbg(FYI,
 906                                  "Set no oplock for inode=%p after a write operation\n",
 907                                  inode);
 908                         cinode->oplock = 0;
 909                 }
 910                 return written;
 911         }
 912
 913         written = cifs_get_writer(cinode);
 914         if (written)
 915                 return written;
 916
 917         written = generic_file_write_iter(iocb, from);
 918
 919         if (CIFS_CACHE_WRITE(CIFS_I(inode)))
 920                 goto out;
 921
 922         rc = filemap_fdatawrite(inode->i_mapping);
 923         if (rc)
 924                 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
 925                          rc, inode);
 926
 927 out:
 928         cifs_put_writer(cinode);
 929         return written;
 930 }
 931
 932 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
 933 {
 934         struct cifsFileInfo *cfile = file->private_data;
 935         struct cifs_tcon *tcon;
 936
 937         /*
 938          * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
 939          * the cached file length
 940          */
 941         if (whence != SEEK_SET && whence != SEEK_CUR) {
 942                 int rc;
 943                 struct inode *inode = file_inode(file);
 944
 945                 /*
 946                  * We need to be sure that all dirty pages are written and the
 947                  * server has the newest file length.
 948                  */
 949                 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
 950                     inode->i_mapping->nrpages != 0) {
 951                         rc = filemap_fdatawait(inode->i_mapping);
 952                         if (rc) {
 953                                 mapping_set_error(inode->i_mapping, rc);
 954                                 return rc;
 955                         }
 956                 }
 957                 /*
 958                  * Some applications poll for the file length in this strange
 959                  * way so we must seek to end on non-oplocked files by
 960                  * setting the revalidate time to zero.
 961                  */
 962                 CIFS_I(inode)->time = 0;
 963
 964                 rc = cifs_revalidate_file_attr(file);
 965                 if (rc < 0)
 966                         return (loff_t)rc;
 967         }
 968         if (cfile && cfile->tlink) {
 969                 tcon = tlink_tcon(cfile->tlink);
 970                 if (tcon->ses->server->ops->llseek)
 971                         return tcon->ses->server->ops->llseek(file, tcon,
 972                                                               offset, whence);
 973         }
 974         return generic_file_llseek(file, offset, whence);
 975 }
 976
 977 static int
 978 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
 979 {
 980         /*
 981          * Note that this is called by vfs setlease with i_lock held to
 982          * protect *lease from going away.
 983          */
 984         struct inode *inode = file_inode(file);
 985         struct cifsFileInfo *cfile = file->private_data;
 986
 987         if (!(S_ISREG(inode->i_mode)))
 988                 return -EINVAL;
 989
 990         /* Check if file is oplocked if this is request for new lease */
 991         if (arg == F_UNLCK ||
 992             ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
 993             ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
 994                 return generic_setlease(file, arg, lease, priv);
 995         else if (tlink_tcon(cfile->tlink)->local_lease &&
 996                  !CIFS_CACHE_READ(CIFS_I(inode)))
 997                 /*
 998                  * If the server claims to support oplock on this file, then we
 999                  * still need to check oplock even if the local_lease mount
1000                  * option is set, but there are servers which do not support
1001                  * oplock for which this mount option may be useful if the user
1002                  * knows that the file won't be changed on the server by anyone
1003                  * else.
1004                  */
1005                 return generic_setlease(file, arg, lease, priv);
1006         else
1007                 return -EAGAIN;
1008 }
1009
1010 struct file_system_type cifs_fs_type = {
1011         .owner = THIS_MODULE,
1012         .name = "cifs",
1013         .mount = cifs_do_mount,
1014         .kill_sb = cifs_kill_sb,
1015         /*  .fs_flags */
1016 };
1017 MODULE_ALIAS_FS("cifs");
1018
1019 static struct file_system_type smb3_fs_type = {
1020         .owner = THIS_MODULE,
1021         .name = "smb3",
1022         .mount = smb3_do_mount,
1023         .kill_sb = cifs_kill_sb,
1024         /*  .fs_flags */
1025 };
1026 MODULE_ALIAS_FS("smb3");
1027 MODULE_ALIAS("smb3");
1028
1029 const struct inode_operations cifs_dir_inode_ops = {
1030         .create = cifs_create,
1031         .atomic_open = cifs_atomic_open,
1032         .lookup = cifs_lookup,
1033         .getattr = cifs_getattr,
1034         .unlink = cifs_unlink,
1035         .link = cifs_hardlink,
1036         .mkdir = cifs_mkdir,
1037         .rmdir = cifs_rmdir,
1038         .rename = cifs_rename2,
1039         .permission = cifs_permission,
1040         .setattr = cifs_setattr,
1041         .symlink = cifs_symlink,
1042         .mknod   = cifs_mknod,
1043         .listxattr = cifs_listxattr,
1044 };
1045
1046 const struct inode_operations cifs_file_inode_ops = {
1047         .setattr = cifs_setattr,
1048         .getattr = cifs_getattr,
1049         .permission = cifs_permission,
1050         .listxattr = cifs_listxattr,
1051         .fiemap = cifs_fiemap,
1052 };
1053
1054 const struct inode_operations cifs_symlink_inode_ops = {
1055         .get_link = cifs_get_link,
1056         .permission = cifs_permission,
1057         .listxattr = cifs_listxattr,
1058 };
1059
1060 static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,
1061                 struct file *dst_file, loff_t destoff, loff_t len,
1062                 unsigned int remap_flags)
1063 {
1064         struct inode *src_inode = file_inode(src_file);
1065         struct inode *target_inode = file_inode(dst_file);
1066         struct cifsFileInfo *smb_file_src = src_file->private_data;
1067         struct cifsFileInfo *smb_file_target;
1068         struct cifs_tcon *target_tcon;
1069         unsigned int xid;
1070         int rc;
1071
1072         if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY))
1073                 return -EINVAL;
1074
1075         cifs_dbg(FYI, "clone range\n");
1076
1077         xid = get_xid();
1078
1079         if (!src_file->private_data || !dst_file->private_data) {
1080                 rc = -EBADF;
1081                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1082                 goto out;
1083         }
1084
1085         smb_file_target = dst_file->private_data;
1086         target_tcon = tlink_tcon(smb_file_target->tlink);
1087
1088         /*
1089          * Note: cifs case is easier than btrfs since server responsible for
1090          * checks for proper open modes and file type and if it wants
1091          * server could even support copy of range where source = target
1092          */
1093         lock_two_nondirectories(target_inode, src_inode);
1094
1095         if (len == 0)
1096                 len = src_inode->i_size - off;
1097
1098         cifs_dbg(FYI, "about to flush pages\n");
1099         /* should we flush first and last page first */
1100         truncate_inode_pages_range(&target_inode->i_data, destoff,
1101                                    PAGE_ALIGN(destoff + len)-1);
1102
1103         if (target_tcon->ses->server->ops->duplicate_extents)
1104                 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
1105                         smb_file_src, smb_file_target, off, len, destoff);
1106         else
1107                 rc = -EOPNOTSUPP;
1108
1109         /* force revalidate of size and timestamps of target file now
1110            that target is updated on the server */
1111         CIFS_I(target_inode)->time = 0;
1112         /* although unlocking in the reverse order from locking is not
1113            strictly necessary here it is a little cleaner to be consistent */
1114         unlock_two_nondirectories(src_inode, target_inode);
1115 out:
1116         free_xid(xid);
1117         return rc < 0 ? rc : len;
1118 }
1119
1120 ssize_t cifs_file_copychunk_range(unsigned int xid,
1121                                 struct file *src_file, loff_t off,
1122                                 struct file *dst_file, loff_t destoff,
1123                                 size_t len, unsigned int flags)
1124 {
1125         struct inode *src_inode = file_inode(src_file);
1126         struct inode *target_inode = file_inode(dst_file);
1127         struct cifsFileInfo *smb_file_src;
1128         struct cifsFileInfo *smb_file_target;
1129         struct cifs_tcon *src_tcon;
1130         struct cifs_tcon *target_tcon;
1131         ssize_t rc;
1132
1133         cifs_dbg(FYI, "copychunk range\n");
1134
1135         if (!src_file->private_data || !dst_file->private_data) {
1136                 rc = -EBADF;
1137                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1138                 goto out;
1139         }
1140
1141         rc = -EXDEV;
1142         smb_file_target = dst_file->private_data;
1143         smb_file_src = src_file->private_data;
1144         src_tcon = tlink_tcon(smb_file_src->tlink);
1145         target_tcon = tlink_tcon(smb_file_target->tlink);
1146
1147         if (src_tcon->ses != target_tcon->ses) {
1148                 cifs_dbg(VFS, "source and target of copy not on same server\n");
1149                 goto out;
1150         }
1151
1152         rc = -EOPNOTSUPP;
1153         if (!target_tcon->ses->server->ops->copychunk_range)
1154                 goto out;
1155
1156         /*
1157          * Note: cifs case is easier than btrfs since server responsible for
1158          * checks for proper open modes and file type and if it wants
1159          * server could even support copy of range where source = target
1160          */
1161         lock_two_nondirectories(target_inode, src_inode);
1162
1163         cifs_dbg(FYI, "about to flush pages\n");
1164         /* should we flush first and last page first */
1165         truncate_inode_pages(&target_inode->i_data, 0);
1166
1167         rc = file_modified(dst_file);
1168         if (!rc)
1169                 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1170                         smb_file_src, smb_file_target, off, len, destoff);
1171
1172         file_accessed(src_file);
1173
1174         /* force revalidate of size and timestamps of target file now
1175          * that target is updated on the server
1176          */
1177         CIFS_I(target_inode)->time = 0;
1178         /* although unlocking in the reverse order from locking is not
1179          * strictly necessary here it is a little cleaner to be consistent
1180          */
1181         unlock_two_nondirectories(src_inode, target_inode);
1182
1183 out:
1184         return rc;
1185 }
1186
1187 /*
1188  * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1189  * is a dummy operation.
1190  */
1191 static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1192 {
1193         cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1194                  file, datasync);
1195
1196         return 0;
1197 }
1198
1199 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1200                                 struct file *dst_file, loff_t destoff,
1201                                 size_t len, unsigned int flags)
1202 {
1203         unsigned int xid = get_xid();
1204         ssize_t rc;
1205
1206         rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1207                                         len, flags);
1208         free_xid(xid);
1209
1210         if (rc == -EOPNOTSUPP || rc == -EXDEV)
1211                 rc = generic_copy_file_range(src_file, off, dst_file,
1212                                              destoff, len, flags);
1213         return rc;
1214 }
1215
1216 const struct file_operations cifs_file_ops = {
1217         .read_iter = cifs_loose_read_iter,
1218         .write_iter = cifs_file_write_iter,
1219         .open = cifs_open,
1220         .release = cifs_close,
1221         .lock = cifs_lock,
1222         .fsync = cifs_fsync,
1223         .flush = cifs_flush,
1224         .mmap  = cifs_file_mmap,
1225         .splice_read = generic_file_splice_read,
1226         .splice_write = iter_file_splice_write,
1227         .llseek = cifs_llseek,
1228         .unlocked_ioctl = cifs_ioctl,
1229         .copy_file_range = cifs_copy_file_range,
1230         .remap_file_range = cifs_remap_file_range,
1231         .setlease = cifs_setlease,
1232         .fallocate = cifs_fallocate,
1233 };
1234
1235 const struct file_operations cifs_file_strict_ops = {
1236         .read_iter = cifs_strict_readv,
1237         .write_iter = cifs_strict_writev,
1238         .open = cifs_open,
1239         .release = cifs_close,
1240         .lock = cifs_lock,
1241         .fsync = cifs_strict_fsync,
1242         .flush = cifs_flush,
1243         .mmap = cifs_file_strict_mmap,
1244         .splice_read = generic_file_splice_read,
1245         .splice_write = iter_file_splice_write,
1246         .llseek = cifs_llseek,
1247         .unlocked_ioctl = cifs_ioctl,
1248         .copy_file_range = cifs_copy_file_range,
1249         .remap_file_range = cifs_remap_file_range,
1250         .setlease = cifs_setlease,
1251         .fallocate = cifs_fallocate,
1252 };
1253
1254 const struct file_operations cifs_file_direct_ops = {
1255         .read_iter = cifs_direct_readv,
1256         .write_iter = cifs_direct_writev,
1257         .open = cifs_open,
1258         .release = cifs_close,
1259         .lock = cifs_lock,
1260         .fsync = cifs_fsync,
1261         .flush = cifs_flush,
1262         .mmap = cifs_file_mmap,
1263         .splice_read = generic_file_splice_read,
1264         .splice_write = iter_file_splice_write,
1265         .unlocked_ioctl  = cifs_ioctl,
1266         .copy_file_range = cifs_copy_file_range,
1267         .remap_file_range = cifs_remap_file_range,
1268         .llseek = cifs_llseek,
1269         .setlease = cifs_setlease,
1270         .fallocate = cifs_fallocate,
1271 };
1272
1273 const struct file_operations cifs_file_nobrl_ops = {
1274         .read_iter = cifs_loose_read_iter,
1275         .write_iter = cifs_file_write_iter,
1276         .open = cifs_open,
1277         .release = cifs_close,
1278         .fsync = cifs_fsync,
1279         .flush = cifs_flush,
1280         .mmap  = cifs_file_mmap,
1281         .splice_read = generic_file_splice_read,
1282         .splice_write = iter_file_splice_write,
1283         .llseek = cifs_llseek,
1284         .unlocked_ioctl = cifs_ioctl,
1285         .copy_file_range = cifs_copy_file_range,
1286         .remap_file_range = cifs_remap_file_range,
1287         .setlease = cifs_setlease,
1288         .fallocate = cifs_fallocate,
1289 };
1290
1291 const struct file_operations cifs_file_strict_nobrl_ops = {
1292         .read_iter = cifs_strict_readv,
1293         .write_iter = cifs_strict_writev,
1294         .open = cifs_open,
1295         .release = cifs_close,
1296         .fsync = cifs_strict_fsync,
1297         .flush = cifs_flush,
1298         .mmap = cifs_file_strict_mmap,
1299         .splice_read = generic_file_splice_read,
1300         .splice_write = iter_file_splice_write,
1301         .llseek = cifs_llseek,
1302         .unlocked_ioctl = cifs_ioctl,
1303         .copy_file_range = cifs_copy_file_range,
1304         .remap_file_range = cifs_remap_file_range,
1305         .setlease = cifs_setlease,
1306         .fallocate = cifs_fallocate,
1307 };
1308
1309 const struct file_operations cifs_file_direct_nobrl_ops = {
1310         .read_iter = cifs_direct_readv,
1311         .write_iter = cifs_direct_writev,
1312         .open = cifs_open,
1313         .release = cifs_close,
1314         .fsync = cifs_fsync,
1315         .flush = cifs_flush,
1316         .mmap = cifs_file_mmap,
1317         .splice_read = generic_file_splice_read,
1318         .splice_write = iter_file_splice_write,
1319         .unlocked_ioctl  = cifs_ioctl,
1320         .copy_file_range = cifs_copy_file_range,
1321         .remap_file_range = cifs_remap_file_range,
1322         .llseek = cifs_llseek,
1323         .setlease = cifs_setlease,
1324         .fallocate = cifs_fallocate,
1325 };
1326
1327 const struct file_operations cifs_dir_ops = {
1328         .iterate_shared = cifs_readdir,
1329         .release = cifs_closedir,
1330         .read    = generic_read_dir,
1331         .unlocked_ioctl  = cifs_ioctl,
1332         .copy_file_range = cifs_copy_file_range,
1333         .remap_file_range = cifs_remap_file_range,
1334         .llseek = generic_file_llseek,
1335         .fsync = cifs_dir_fsync,
1336 };
1337
1338 static void
1339 cifs_init_once(void *inode)
1340 {
1341         struct cifsInodeInfo *cifsi = inode;
1342
1343         inode_init_once(&cifsi->vfs_inode);
1344         init_rwsem(&cifsi->lock_sem);
1345 }
1346
1347 static int __init
1348 cifs_init_inodecache(void)
1349 {
1350         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1351                                               sizeof(struct cifsInodeInfo),
1352                                               0, (SLAB_RECLAIM_ACCOUNT|
1353                                                 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1354                                               cifs_init_once);
1355         if (cifs_inode_cachep == NULL)
1356                 return -ENOMEM;
1357
1358         return 0;
1359 }
1360
1361 static void
1362 cifs_destroy_inodecache(void)
1363 {
1364         /*
1365          * Make sure all delayed rcu free inodes are flushed before we
1366          * destroy cache.
1367          */
1368         rcu_barrier();
1369         kmem_cache_destroy(cifs_inode_cachep);
1370 }
1371
1372 static int
1373 cifs_init_request_bufs(void)
1374 {
1375         /*
1376          * SMB2 maximum header size is bigger than CIFS one - no problems to
1377          * allocate some more bytes for CIFS.
1378          */
1379         size_t max_hdr_size = MAX_SMB2_HDR_SIZE;
1380
1381         if (CIFSMaxBufSize < 8192) {
1382         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1383         Unicode path name has to fit in any SMB/CIFS path based frames */
1384                 CIFSMaxBufSize = 8192;
1385         } else if (CIFSMaxBufSize > 1024*127) {
1386                 CIFSMaxBufSize = 1024 * 127;
1387         } else {
1388                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1389         }
1390 /*
1391         cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1392                  CIFSMaxBufSize, CIFSMaxBufSize);
1393 */
1394         cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",
1395                                             CIFSMaxBufSize + max_hdr_size, 0,
1396                                             SLAB_HWCACHE_ALIGN, 0,
1397                                             CIFSMaxBufSize + max_hdr_size,
1398                                             NULL);
1399         if (cifs_req_cachep == NULL)
1400                 return -ENOMEM;
1401
1402         if (cifs_min_rcv < 1)
1403                 cifs_min_rcv = 1;
1404         else if (cifs_min_rcv > 64) {
1405                 cifs_min_rcv = 64;
1406                 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1407         }
1408
1409         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1410                                                   cifs_req_cachep);
1411
1412         if (cifs_req_poolp == NULL) {
1413                 kmem_cache_destroy(cifs_req_cachep);
1414                 return -ENOMEM;
1415         }
1416         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1417         almost all handle based requests (but not write response, nor is it
1418         sufficient for path based requests).  A smaller size would have
1419         been more efficient (compacting multiple slab items on one 4k page)
1420         for the case in which debug was on, but this larger size allows
1421         more SMBs to use small buffer alloc and is still much more
1422         efficient to alloc 1 per page off the slab compared to 17K (5page)
1423         alloc of large cifs buffers even when page debugging is on */
1424         cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",
1425                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1426                         0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);
1427         if (cifs_sm_req_cachep == NULL) {
1428                 mempool_destroy(cifs_req_poolp);
1429                 kmem_cache_destroy(cifs_req_cachep);
1430                 return -ENOMEM;
1431         }
1432
1433         if (cifs_min_small < 2)
1434                 cifs_min_small = 2;
1435         else if (cifs_min_small > 256) {
1436                 cifs_min_small = 256;
1437                 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1438         }
1439
1440         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1441                                                      cifs_sm_req_cachep);
1442
1443         if (cifs_sm_req_poolp == NULL) {
1444                 mempool_destroy(cifs_req_poolp);
1445                 kmem_cache_destroy(cifs_req_cachep);
1446                 kmem_cache_destroy(cifs_sm_req_cachep);
1447                 return -ENOMEM;
1448         }
1449
1450         return 0;
1451 }
1452
1453 static void
1454 cifs_destroy_request_bufs(void)
1455 {
1456         mempool_destroy(cifs_req_poolp);
1457         kmem_cache_destroy(cifs_req_cachep);
1458         mempool_destroy(cifs_sm_req_poolp);
1459         kmem_cache_destroy(cifs_sm_req_cachep);
1460 }
1461
1462 static int
1463 cifs_init_mids(void)
1464 {
1465         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1466                                             sizeof(struct mid_q_entry), 0,
1467                                             SLAB_HWCACHE_ALIGN, NULL);
1468         if (cifs_mid_cachep == NULL)
1469                 return -ENOMEM;
1470
1471         /* 3 is a reasonable minimum number of simultaneous operations */
1472         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1473         if (cifs_mid_poolp == NULL) {
1474                 kmem_cache_destroy(cifs_mid_cachep);
1475                 return -ENOMEM;
1476         }
1477
1478         return 0;
1479 }
1480
1481 static void
1482 cifs_destroy_mids(void)
1483 {
1484         mempool_destroy(cifs_mid_poolp);
1485         kmem_cache_destroy(cifs_mid_cachep);
1486 }
1487
1488 static int __init
1489 init_cifs(void)
1490 {
1491         int rc = 0;
1492         cifs_proc_init();
1493         INIT_LIST_HEAD(&cifs_tcp_ses_list);
1494 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1495         INIT_LIST_HEAD(&GlobalDnotifyReqList);
1496         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1497 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1498 /*
1499  *  Initialize Global counters
1500  */
1501         atomic_set(&sesInfoAllocCount, 0);
1502         atomic_set(&tconInfoAllocCount, 0);
1503         atomic_set(&tcpSesAllocCount, 0);
1504         atomic_set(&tcpSesReconnectCount, 0);
1505         atomic_set(&tconInfoReconnectCount, 0);
1506
1507         atomic_set(&bufAllocCount, 0);
1508         atomic_set(&smBufAllocCount, 0);
1509 #ifdef CONFIG_CIFS_STATS2
1510         atomic_set(&totBufAllocCount, 0);
1511         atomic_set(&totSmBufAllocCount, 0);
1512         if (slow_rsp_threshold < 1)
1513                 cifs_dbg(FYI, "slow_response_threshold msgs disabled\n");
1514         else if (slow_rsp_threshold > 32767)
1515                 cifs_dbg(VFS,
1516                        "slow response threshold set higher than recommended (0 to 32767)\n");
1517 #endif /* CONFIG_CIFS_STATS2 */
1518
1519         atomic_set(&midCount, 0);
1520         GlobalCurrentXid = 0;
1521         GlobalTotalActiveXid = 0;
1522         GlobalMaxActiveXid = 0;
1523         spin_lock_init(&cifs_tcp_ses_lock);
1524         spin_lock_init(&GlobalMid_Lock);
1525
1526         cifs_lock_secret = get_random_u32();
1527
1528         if (cifs_max_pending < 2) {
1529                 cifs_max_pending = 2;
1530                 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1531         } else if (cifs_max_pending > CIFS_MAX_REQ) {
1532                 cifs_max_pending = CIFS_MAX_REQ;
1533                 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1534                          CIFS_MAX_REQ);
1535         }
1536
1537         cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1538         if (!cifsiod_wq) {
1539                 rc = -ENOMEM;
1540                 goto out_clean_proc;
1541         }
1542
1543         /*
1544          * Consider in future setting limit!=0 maybe to min(num_of_cores - 1, 3)
1545          * so that we don't launch too many worker threads but
1546          * Documentation/workqueue.txt recommends setting it to 0
1547          */
1548
1549         /* WQ_UNBOUND allows decrypt tasks to run on any CPU */
1550         decrypt_wq = alloc_workqueue("smb3decryptd",
1551                                      WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1552         if (!decrypt_wq) {
1553                 rc = -ENOMEM;
1554                 goto out_destroy_cifsiod_wq;
1555         }
1556
1557         cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1558                                          WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1559         if (!cifsoplockd_wq) {
1560                 rc = -ENOMEM;
1561                 goto out_destroy_decrypt_wq;
1562         }
1563
1564         rc = cifs_fscache_register();
1565         if (rc)
1566                 goto out_destroy_cifsoplockd_wq;
1567
1568         rc = cifs_init_inodecache();
1569         if (rc)
1570                 goto out_unreg_fscache;
1571
1572         rc = cifs_init_mids();
1573         if (rc)
1574                 goto out_destroy_inodecache;
1575
1576         rc = cifs_init_request_bufs();
1577         if (rc)
1578                 goto out_destroy_mids;
1579
1580 #ifdef CONFIG_CIFS_DFS_UPCALL
1581         rc = dfs_cache_init();
1582         if (rc)
1583                 goto out_destroy_request_bufs;
1584 #endif /* CONFIG_CIFS_DFS_UPCALL */
1585 #ifdef CONFIG_CIFS_UPCALL
1586         rc = init_cifs_spnego();
1587         if (rc)
1588                 goto out_destroy_dfs_cache;
1589 #endif /* CONFIG_CIFS_UPCALL */
1590
1591         rc = init_cifs_idmap();
1592         if (rc)
1593                 goto out_register_key_type;
1594
1595         rc = register_filesystem(&cifs_fs_type);
1596         if (rc)
1597                 goto out_init_cifs_idmap;
1598
1599         rc = register_filesystem(&smb3_fs_type);
1600         if (rc) {
1601                 unregister_filesystem(&cifs_fs_type);
1602                 goto out_init_cifs_idmap;
1603         }
1604
1605         return 0;
1606
1607 out_init_cifs_idmap:
1608         exit_cifs_idmap();
1609 out_register_key_type:
1610 #ifdef CONFIG_CIFS_UPCALL
1611         exit_cifs_spnego();
1612 out_destroy_dfs_cache:
1613 #endif
1614 #ifdef CONFIG_CIFS_DFS_UPCALL
1615         dfs_cache_destroy();
1616 out_destroy_request_bufs:
1617 #endif
1618         cifs_destroy_request_bufs();
1619 out_destroy_mids:
1620         cifs_destroy_mids();
1621 out_destroy_inodecache:
1622         cifs_destroy_inodecache();
1623 out_unreg_fscache:
1624         cifs_fscache_unregister();
1625 out_destroy_cifsoplockd_wq:
1626         destroy_workqueue(cifsoplockd_wq);
1627 out_destroy_decrypt_wq:
1628         destroy_workqueue(decrypt_wq);
1629 out_destroy_cifsiod_wq:
1630         destroy_workqueue(cifsiod_wq);
1631 out_clean_proc:
1632         cifs_proc_clean();
1633         return rc;
1634 }
1635
1636 static void __exit
1637 exit_cifs(void)
1638 {
1639         cifs_dbg(NOISY, "exit_smb3\n");
1640         unregister_filesystem(&cifs_fs_type);
1641         unregister_filesystem(&smb3_fs_type);
1642         cifs_dfs_release_automount_timer();
1643         exit_cifs_idmap();
1644 #ifdef CONFIG_CIFS_UPCALL
1645         exit_cifs_spnego();
1646 #endif
1647 #ifdef CONFIG_CIFS_DFS_UPCALL
1648         dfs_cache_destroy();
1649 #endif
1650         cifs_destroy_request_bufs();
1651         cifs_destroy_mids();
1652         cifs_destroy_inodecache();
1653         cifs_fscache_unregister();
1654         destroy_workqueue(cifsoplockd_wq);
1655         destroy_workqueue(decrypt_wq);
1656         destroy_workqueue(cifsiod_wq);
1657         cifs_proc_clean();
1658 }
1659
1660 MODULE_AUTHOR("Steve French");
1661 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1662 MODULE_DESCRIPTION
1663         ("VFS to access SMB3 servers e.g. Samba, Macs, Azure and Windows (and "
1664         "also older servers complying with the SNIA CIFS Specification)");
1665 MODULE_VERSION(CIFS_VERSION);
1666 MODULE_SOFTDEP("pre: ecb");
1667 MODULE_SOFTDEP("pre: hmac");
1668 MODULE_SOFTDEP("pre: md4");
1669 MODULE_SOFTDEP("pre: md5");
1670 MODULE_SOFTDEP("pre: nls");
1671 MODULE_SOFTDEP("pre: aes");
1672 MODULE_SOFTDEP("pre: cmac");
1673 MODULE_SOFTDEP("pre: sha256");
1674 MODULE_SOFTDEP("pre: sha512");
1675 MODULE_SOFTDEP("pre: aead2");
1676 MODULE_SOFTDEP("pre: ccm");
1677 MODULE_SOFTDEP("pre: gcm");
1678 module_init(init_cifs)
1679 module_exit(exit_cifs)