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