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