fs/cifs/cifsfs.c

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