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