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