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