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 *cifsoplockd_wq;
 123 __u32 cifs_lock_secret;
 124
 125 /*
 126  * Bumps refcount for cifs super block.
 127  * Note that it should be only called if a referece to VFS super block is
 128  * already held, e.g. in open-type syscalls context. Otherwise it can race with
 129  * atomic_dec_and_test in deactivate_locked_super.
 130  */
 131 void
 132 cifs_sb_active(struct super_block *sb)
 133 {
 134         struct cifs_sb_info *server = CIFS_SB(sb);
 135
 136         if (atomic_inc_return(&server->active) == 1)
 137                 atomic_inc(&sb->s_active);
 138 }
 139
 140 void
 141 cifs_sb_deactive(struct super_block *sb)
 142 {
 143         struct cifs_sb_info *server = CIFS_SB(sb);
 144
 145         if (atomic_dec_and_test(&server->active))
 146                 deactivate_super(sb);
 147 }
 148
 149 static int
 150 cifs_read_super(struct super_block *sb)
 151 {
 152         struct inode *inode;
 153         struct cifs_sb_info *cifs_sb;
 154         struct cifs_tcon *tcon;
 155         struct timespec64 ts;
 156         int rc = 0;
 157
 158         cifs_sb = CIFS_SB(sb);
 159         tcon = cifs_sb_master_tcon(cifs_sb);
 160
 161         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
 162                 sb->s_flags |= SB_POSIXACL;
 163
 164         if (tcon->snapshot_time)
 165                 sb->s_flags |= SB_RDONLY;
 166
 167         if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
 168                 sb->s_maxbytes = MAX_LFS_FILESIZE;
 169         else
 170                 sb->s_maxbytes = MAX_NON_LFS;
 171
 172         /*
 173          * Some very old servers like DOS and OS/2 used 2 second granularity
 174          * (while all current servers use 100ns granularity - see MS-DTYP)
 175          * but 1 second is the maximum allowed granularity for the VFS
 176          * so for old servers set time granularity to 1 second while for
 177          * everything else (current servers) set it to 100ns.
 178          */
 179         if ((tcon->ses->server->vals->protocol_id == SMB10_PROT_ID) &&
 180             ((tcon->ses->capabilities &
 181               tcon->ses->server->vals->cap_nt_find) == 0) &&
 182             !tcon->unix_ext) {
 183                 sb->s_time_gran = 1000000000; /* 1 second is max allowed gran */
 184                 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MIN), 0, 0);
 185                 sb->s_time_min = ts.tv_sec;
 186                 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MAX),
 187                                     cpu_to_le16(SMB_TIME_MAX), 0);
 188                 sb->s_time_max = ts.tv_sec;
 189         } else {
 190                 /*
 191                  * Almost every server, including all SMB2+, uses DCE TIME
 192                  * ie 100 nanosecond units, since 1601.  See MS-DTYP and MS-FSCC
 193                  */
 194                 sb->s_time_gran = 100;
 195                 ts = cifs_NTtimeToUnix(0);
 196                 sb->s_time_min = ts.tv_sec;
 197                 ts = cifs_NTtimeToUnix(cpu_to_le64(S64_MAX));
 198                 sb->s_time_max = ts.tv_sec;
 199         }
 200
 201         sb->s_magic = CIFS_MAGIC_NUMBER;
 202         sb->s_op = &cifs_super_ops;
 203         sb->s_xattr = cifs_xattr_handlers;
 204         rc = super_setup_bdi(sb);
 205         if (rc)
 206                 goto out_no_root;
 207         /* tune readahead according to rsize */
 208         sb->s_bdi->ra_pages = cifs_sb->rsize / PAGE_SIZE;
 209
 210         sb->s_blocksize = CIFS_MAX_MSGSIZE;
 211         sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
 212         inode = cifs_root_iget(sb);
 213
 214         if (IS_ERR(inode)) {
 215                 rc = PTR_ERR(inode);
 216                 goto out_no_root;
 217         }
 218
 219         if (tcon->nocase)
 220                 sb->s_d_op = &cifs_ci_dentry_ops;
 221         else
 222                 sb->s_d_op = &cifs_dentry_ops;
 223
 224         sb->s_root = d_make_root(inode);
 225         if (!sb->s_root) {
 226                 rc = -ENOMEM;
 227                 goto out_no_root;
 228         }
 229
 230 #ifdef CONFIG_CIFS_NFSD_EXPORT
 231         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 232                 cifs_dbg(FYI, "export ops supported\n");
 233                 sb->s_export_op = &cifs_export_ops;
 234         }
 235 #endif /* CONFIG_CIFS_NFSD_EXPORT */
 236
 237         return 0;
 238
 239 out_no_root:
 240         cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
 241         return rc;
 242 }
 243
 244 static void cifs_kill_sb(struct super_block *sb)
 245 {
 246         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 247         kill_anon_super(sb);
 248         cifs_umount(cifs_sb);
 249 }
 250
 251 static int
 252 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
 253 {
 254         struct super_block *sb = dentry->d_sb;
 255         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 256         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 257         struct TCP_Server_Info *server = tcon->ses->server;
 258         unsigned int xid;
 259         int rc = 0;
 260
 261         xid = get_xid();
 262
 263         if (le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength) > 0)
 264                 buf->f_namelen =
 265                        le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength);
 266         else
 267                 buf->f_namelen = PATH_MAX;
 268
 269         buf->f_fsid.val[0] = tcon->vol_serial_number;
 270         /* are using part of create time for more randomness, see man statfs */
 271         buf->f_fsid.val[1] =  (int)le64_to_cpu(tcon->vol_create_time);
 272
 273         buf->f_files = 0;       /* undefined */
 274         buf->f_ffree = 0;       /* unlimited */
 275
 276         if (server->ops->queryfs)
 277                 rc = server->ops->queryfs(xid, tcon, buf);
 278
 279         free_xid(xid);
 280         return 0;
 281 }
 282
 283 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
 284 {
 285         struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
 286         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 287         struct TCP_Server_Info *server = tcon->ses->server;
 288
 289         if (server->ops->fallocate)
 290                 return server->ops->fallocate(file, tcon, mode, off, len);
 291
 292         return -EOPNOTSUPP;
 293 }
 294
 295 static int cifs_permission(struct inode *inode, int mask)
 296 {
 297         struct cifs_sb_info *cifs_sb;
 298
 299         cifs_sb = CIFS_SB(inode->i_sb);
 300
 301         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
 302                 if ((mask & MAY_EXEC) && !execute_ok(inode))
 303                         return -EACCES;
 304                 else
 305                         return 0;
 306         } else /* file mode might have been restricted at mount time
 307                 on the client (above and beyond ACL on servers) for
 308                 servers which do not support setting and viewing mode bits,
 309                 so allowing client to check permissions is useful */
 310                 return generic_permission(inode, mask);
 311 }
 312
 313 static struct kmem_cache *cifs_inode_cachep;
 314 static struct kmem_cache *cifs_req_cachep;
 315 static struct kmem_cache *cifs_mid_cachep;
 316 static struct kmem_cache *cifs_sm_req_cachep;
 317 mempool_t *cifs_sm_req_poolp;
 318 mempool_t *cifs_req_poolp;
 319 mempool_t *cifs_mid_poolp;
 320
 321 static struct inode *
 322 cifs_alloc_inode(struct super_block *sb)
 323 {
 324         struct cifsInodeInfo *cifs_inode;
 325         cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
 326         if (!cifs_inode)
 327                 return NULL;
 328         cifs_inode->cifsAttrs = 0x20;   /* default */
 329         cifs_inode->time = 0;
 330         /*
 331          * Until the file is open and we have gotten oplock info back from the
 332          * server, can not assume caching of file data or metadata.
 333          */
 334         cifs_set_oplock_level(cifs_inode, 0);
 335         cifs_inode->flags = 0;
 336         spin_lock_init(&cifs_inode->writers_lock);
 337         cifs_inode->writers = 0;
 338         cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
 339         cifs_inode->server_eof = 0;
 340         cifs_inode->uniqueid = 0;
 341         cifs_inode->createtime = 0;
 342         cifs_inode->epoch = 0;
 343         spin_lock_init(&cifs_inode->open_file_lock);
 344         generate_random_uuid(cifs_inode->lease_key);
 345
 346         /*
 347          * Can not set i_flags here - they get immediately overwritten to zero
 348          * by the VFS.
 349          */
 350         /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
 351         INIT_LIST_HEAD(&cifs_inode->openFileList);
 352         INIT_LIST_HEAD(&cifs_inode->llist);
 353         return &cifs_inode->vfs_inode;
 354 }
 355
 356 static void
 357 cifs_free_inode(struct inode *inode)
 358 {
 359         kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
 360 }
 361
 362 static void
 363 cifs_evict_inode(struct inode *inode)
 364 {
 365         truncate_inode_pages_final(&inode->i_data);
 366         clear_inode(inode);
 367         cifs_fscache_release_inode_cookie(inode);
 368 }
 369
 370 static void
 371 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
 372 {
 373         struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
 374         struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
 375
 376         seq_puts(s, ",addr=");
 377
 378         switch (server->dstaddr.ss_family) {
 379         case AF_INET:
 380                 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
 381                 break;
 382         case AF_INET6:
 383                 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
 384                 if (sa6->sin6_scope_id)
 385                         seq_printf(s, "%%%u", sa6->sin6_scope_id);
 386                 break;
 387         default:
 388                 seq_puts(s, "(unknown)");
 389         }
 390         if (server->rdma)
 391                 seq_puts(s, ",rdma");
 392 }
 393
 394 static void
 395 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
 396 {
 397         if (ses->sectype == Unspecified) {
 398                 if (ses->user_name == NULL)
 399                         seq_puts(s, ",sec=none");
 400                 return;
 401         }
 402
 403         seq_puts(s, ",sec=");
 404
 405         switch (ses->sectype) {
 406         case LANMAN:
 407                 seq_puts(s, "lanman");
 408                 break;
 409         case NTLMv2:
 410                 seq_puts(s, "ntlmv2");
 411                 break;
 412         case NTLM:
 413                 seq_puts(s, "ntlm");
 414                 break;
 415         case Kerberos:
 416                 seq_printf(s, "krb5,cruid=%u", from_kuid_munged(&init_user_ns,ses->cred_uid));
 417                 break;
 418         case RawNTLMSSP:
 419                 seq_puts(s, "ntlmssp");
 420                 break;
 421         default:
 422                 /* shouldn't ever happen */
 423                 seq_puts(s, "unknown");
 424                 break;
 425         }
 426
 427         if (ses->sign)
 428                 seq_puts(s, "i");
 429 }
 430
 431 static void
 432 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
 433 {
 434         seq_puts(s, ",cache=");
 435
 436         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 437                 seq_puts(s, "strict");
 438         else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
 439                 seq_puts(s, "none");
 440         else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
 441                 seq_puts(s, "singleclient"); /* assume only one client access */
 442         else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE)
 443                 seq_puts(s, "ro"); /* read only caching assumed */
 444         else
 445                 seq_puts(s, "loose");
 446 }
 447
 448 static void
 449 cifs_show_nls(struct seq_file *s, struct nls_table *cur)
 450 {
 451         struct nls_table *def;
 452
 453         /* Display iocharset= option if it's not default charset */
 454         def = load_nls_default();
 455         if (def != cur)
 456                 seq_printf(s, ",iocharset=%s", cur->charset);
 457         unload_nls(def);
 458 }
 459
 460 /*
 461  * cifs_show_options() is for displaying mount options in /proc/mounts.
 462  * Not all settable options are displayed but most of the important
 463  * ones are.
 464  */
 465 static int
 466 cifs_show_options(struct seq_file *s, struct dentry *root)
 467 {
 468         struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
 469         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 470         struct sockaddr *srcaddr;
 471         srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
 472
 473         seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
 474         cifs_show_security(s, tcon->ses);
 475         cifs_show_cache_flavor(s, cifs_sb);
 476
 477         if (tcon->no_lease)
 478                 seq_puts(s, ",nolease");
 479         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
 480                 seq_puts(s, ",multiuser");
 481         else if (tcon->ses->user_name)
 482                 seq_show_option(s, "username", tcon->ses->user_name);
 483
 484         if (tcon->ses->domainName && tcon->ses->domainName[0] != 0)
 485                 seq_show_option(s, "domain", tcon->ses->domainName);
 486
 487         if (srcaddr->sa_family != AF_UNSPEC) {
 488                 struct sockaddr_in *saddr4;
 489                 struct sockaddr_in6 *saddr6;
 490                 saddr4 = (struct sockaddr_in *)srcaddr;
 491                 saddr6 = (struct sockaddr_in6 *)srcaddr;
 492                 if (srcaddr->sa_family == AF_INET6)
 493                         seq_printf(s, ",srcaddr=%pI6c",
 494                                    &saddr6->sin6_addr);
 495                 else if (srcaddr->sa_family == AF_INET)
 496                         seq_printf(s, ",srcaddr=%pI4",
 497                                    &saddr4->sin_addr.s_addr);
 498                 else
 499                         seq_printf(s, ",srcaddr=BAD-AF:%i",
 500                                    (int)(srcaddr->sa_family));
 501         }
 502
 503         seq_printf(s, ",uid=%u",
 504                    from_kuid_munged(&init_user_ns, cifs_sb->mnt_uid));
 505         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
 506                 seq_puts(s, ",forceuid");
 507         else
 508                 seq_puts(s, ",noforceuid");
 509
 510         seq_printf(s, ",gid=%u",
 511                    from_kgid_munged(&init_user_ns, cifs_sb->mnt_gid));
 512         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
 513                 seq_puts(s, ",forcegid");
 514         else
 515                 seq_puts(s, ",noforcegid");
 516
 517         cifs_show_address(s, tcon->ses->server);
 518
 519         if (!tcon->unix_ext)
 520                 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
 521                                            cifs_sb->mnt_file_mode,
 522                                            cifs_sb->mnt_dir_mode);
 523
 524         cifs_show_nls(s, cifs_sb->local_nls);
 525
 526         if (tcon->seal)
 527                 seq_puts(s, ",seal");
 528         if (tcon->nocase)
 529                 seq_puts(s, ",nocase");
 530         if (tcon->local_lease)
 531                 seq_puts(s, ",locallease");
 532         if (tcon->retry)
 533                 seq_puts(s, ",hard");
 534         else
 535                 seq_puts(s, ",soft");
 536         if (tcon->use_persistent)
 537                 seq_puts(s, ",persistenthandles");
 538         else if (tcon->use_resilient)
 539                 seq_puts(s, ",resilienthandles");
 540         if (tcon->posix_extensions)
 541                 seq_puts(s, ",posix");
 542         else if (tcon->unix_ext)
 543                 seq_puts(s, ",unix");
 544         else
 545                 seq_puts(s, ",nounix");
 546         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
 547                 seq_puts(s, ",nodfs");
 548         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
 549                 seq_puts(s, ",posixpaths");
 550         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
 551                 seq_puts(s, ",setuids");
 552         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
 553                 seq_puts(s, ",idsfromsid");
 554         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 555                 seq_puts(s, ",serverino");
 556         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
 557                 seq_puts(s, ",rwpidforward");
 558         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
 559                 seq_puts(s, ",forcemand");
 560         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 561                 seq_puts(s, ",nouser_xattr");
 562         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
 563                 seq_puts(s, ",mapchars");
 564         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
 565                 seq_puts(s, ",mapposix");
 566         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
 567                 seq_puts(s, ",sfu");
 568         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 569                 seq_puts(s, ",nobrl");
 570         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_HANDLE_CACHE)
 571                 seq_puts(s, ",nohandlecache");
 572         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)
 573                 seq_puts(s, ",modefromsid");
 574         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
 575                 seq_puts(s, ",cifsacl");
 576         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
 577                 seq_puts(s, ",dynperm");
 578         if (root->d_sb->s_flags & SB_POSIXACL)
 579                 seq_puts(s, ",acl");
 580         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
 581                 seq_puts(s, ",mfsymlinks");
 582         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
 583                 seq_puts(s, ",fsc");
 584         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
 585                 seq_puts(s, ",nostrictsync");
 586         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
 587                 seq_puts(s, ",noperm");
 588         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
 589                 seq_printf(s, ",backupuid=%u",
 590                            from_kuid_munged(&init_user_ns,
 591                                             cifs_sb->mnt_backupuid));
 592         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
 593                 seq_printf(s, ",backupgid=%u",
 594                            from_kgid_munged(&init_user_ns,
 595                                             cifs_sb->mnt_backupgid));
 596
 597         seq_printf(s, ",rsize=%u", cifs_sb->rsize);
 598         seq_printf(s, ",wsize=%u", cifs_sb->wsize);
 599         seq_printf(s, ",bsize=%u", cifs_sb->bsize);
 600         if (tcon->ses->server->min_offload)
 601                 seq_printf(s, ",esize=%u", tcon->ses->server->min_offload);
 602         seq_printf(s, ",echo_interval=%lu",
 603                         tcon->ses->server->echo_interval / HZ);
 604
 605         /* Only display max_credits if it was overridden on mount */
 606         if (tcon->ses->server->max_credits != SMB2_MAX_CREDITS_AVAILABLE)
 607                 seq_printf(s, ",max_credits=%u", tcon->ses->server->max_credits);
 608
 609         if (tcon->snapshot_time)
 610                 seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);
 611         if (tcon->handle_timeout)
 612                 seq_printf(s, ",handletimeout=%u", tcon->handle_timeout);
 613         /* convert actimeo and display it in seconds */
 614         seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
 615
 616         if (tcon->ses->chan_max > 1)
 617                 seq_printf(s, ",multichannel,max_channel=%zu",
 618                            tcon->ses->chan_max);
 619
 620         return 0;
 621 }
 622
 623 static void cifs_umount_begin(struct super_block *sb)
 624 {
 625         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 626         struct cifs_tcon *tcon;
 627
 628         if (cifs_sb == NULL)
 629                 return;
 630
 631         tcon = cifs_sb_master_tcon(cifs_sb);
 632
 633         spin_lock(&cifs_tcp_ses_lock);
 634         if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
 635                 /* we have other mounts to same share or we have
 636                    already tried to force umount this and woken up
 637                    all waiting network requests, nothing to do */
 638                 spin_unlock(&cifs_tcp_ses_lock);
 639                 return;
 640         } else if (tcon->tc_count == 1)
 641                 tcon->tidStatus = CifsExiting;
 642         spin_unlock(&cifs_tcp_ses_lock);
 643
 644         /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
 645         /* cancel_notify_requests(tcon); */
 646         if (tcon->ses && tcon->ses->server) {
 647                 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
 648                 wake_up_all(&tcon->ses->server->request_q);
 649                 wake_up_all(&tcon->ses->server->response_q);
 650                 msleep(1); /* yield */
 651                 /* we have to kick the requests once more */
 652                 wake_up_all(&tcon->ses->server->response_q);
 653                 msleep(1);
 654         }
 655
 656         return;
 657 }
 658
 659 #ifdef CONFIG_CIFS_STATS2
 660 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
 661 {
 662         /* BB FIXME */
 663         return 0;
 664 }
 665 #endif
 666
 667 static int cifs_remount(struct super_block *sb, int *flags, char *data)
 668 {
 669         sync_filesystem(sb);
 670         *flags |= SB_NODIRATIME;
 671         return 0;
 672 }
 673
 674 static int cifs_drop_inode(struct inode *inode)
 675 {
 676         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 677
 678         /* no serverino => unconditional eviction */
 679         return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
 680                 generic_drop_inode(inode);
 681 }
 682
 683 static const struct super_operations cifs_super_ops = {
 684         .statfs = cifs_statfs,
 685         .alloc_inode = cifs_alloc_inode,
 686         .free_inode = cifs_free_inode,
 687         .drop_inode     = cifs_drop_inode,
 688         .evict_inode    = cifs_evict_inode,
 689 /*      .delete_inode   = cifs_delete_inode,  */  /* Do not need above
 690         function unless later we add lazy close of inodes or unless the
 691         kernel forgets to call us with the same number of releases (closes)
 692         as opens */
 693         .show_options = cifs_show_options,
 694         .umount_begin   = cifs_umount_begin,
 695         .remount_fs = cifs_remount,
 696 #ifdef CONFIG_CIFS_STATS2
 697         .show_stats = cifs_show_stats,
 698 #endif
 699 };
 700
 701 /*
 702  * Get root dentry from superblock according to prefix path mount option.
 703  * Return dentry with refcount + 1 on success and NULL otherwise.
 704  */
 705 static struct dentry *
 706 cifs_get_root(struct smb_vol *vol, struct super_block *sb)
 707 {
 708         struct dentry *dentry;
 709         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 710         char *full_path = NULL;
 711         char *s, *p;
 712         char sep;
 713
 714         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
 715                 return dget(sb->s_root);
 716
 717         full_path = cifs_build_path_to_root(vol, cifs_sb,
 718                                 cifs_sb_master_tcon(cifs_sb), 0);
 719         if (full_path == NULL)
 720                 return ERR_PTR(-ENOMEM);
 721
 722         cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
 723
 724         sep = CIFS_DIR_SEP(cifs_sb);
 725         dentry = dget(sb->s_root);
 726         p = s = full_path;
 727
 728         do {
 729                 struct inode *dir = d_inode(dentry);
 730                 struct dentry *child;
 731
 732                 if (!dir) {
 733                         dput(dentry);
 734                         dentry = ERR_PTR(-ENOENT);
 735                         break;
 736                 }
 737                 if (!S_ISDIR(dir->i_mode)) {
 738                         dput(dentry);
 739                         dentry = ERR_PTR(-ENOTDIR);
 740                         break;
 741                 }
 742
 743                 /* skip separators */
 744                 while (*s == sep)
 745                         s++;
 746                 if (!*s)
 747                         break;
 748                 p = s++;
 749                 /* next separator */
 750                 while (*s && *s != sep)
 751                         s++;
 752
 753                 child = lookup_one_len_unlocked(p, dentry, s - p);
 754                 dput(dentry);
 755                 dentry = child;
 756         } while (!IS_ERR(dentry));
 757         kfree(full_path);
 758         return dentry;
 759 }
 760
 761 static int cifs_set_super(struct super_block *sb, void *data)
 762 {
 763         struct cifs_mnt_data *mnt_data = data;
 764         sb->s_fs_info = mnt_data->cifs_sb;
 765         return set_anon_super(sb, NULL);
 766 }
 767
 768 static struct dentry *
 769 cifs_smb3_do_mount(struct file_system_type *fs_type,
 770               int flags, const char *dev_name, void *data, bool is_smb3)
 771 {
 772         int rc;
 773         struct super_block *sb;
 774         struct cifs_sb_info *cifs_sb;
 775         struct smb_vol *volume_info;
 776         struct cifs_mnt_data mnt_data;
 777         struct dentry *root;
 778
 779         /*
 780          * Prints in Kernel / CIFS log the attempted mount operation
 781          *      If CIFS_DEBUG && cifs_FYI
 782          */
 783         if (cifsFYI)
 784                 cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
 785         else
 786                 cifs_info("Attempting to mount %s\n", dev_name);
 787
 788         volume_info = cifs_get_volume_info((char *)data, dev_name, is_smb3);
 789         if (IS_ERR(volume_info))
 790                 return ERR_CAST(volume_info);
 791
 792         cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
 793         if (cifs_sb == NULL) {
 794                 root = ERR_PTR(-ENOMEM);
 795                 goto out_nls;
 796         }
 797
 798         cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
 799         if (cifs_sb->mountdata == NULL) {
 800                 root = ERR_PTR(-ENOMEM);
 801                 goto out_free;
 802         }
 803
 804         rc = cifs_setup_cifs_sb(volume_info, cifs_sb);
 805         if (rc) {
 806                 root = ERR_PTR(rc);
 807                 goto out_free;
 808         }
 809
 810         rc = cifs_mount(cifs_sb, volume_info);
 811         if (rc) {
 812                 if (!(flags & SB_SILENT))
 813                         cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
 814                                  rc);
 815                 root = ERR_PTR(rc);
 816                 goto out_free;
 817         }
 818
 819         mnt_data.vol = volume_info;
 820         mnt_data.cifs_sb = cifs_sb;
 821         mnt_data.flags = flags;
 822
 823         /* BB should we make this contingent on mount parm? */
 824         flags |= SB_NODIRATIME | SB_NOATIME;
 825
 826         sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
 827         if (IS_ERR(sb)) {
 828                 root = ERR_CAST(sb);
 829                 cifs_umount(cifs_sb);
 830                 goto out;
 831         }
 832
 833         if (sb->s_root) {
 834                 cifs_dbg(FYI, "Use existing superblock\n");
 835                 cifs_umount(cifs_sb);
 836         } else {
 837                 rc = cifs_read_super(sb);
 838                 if (rc) {
 839                         root = ERR_PTR(rc);
 840                         goto out_super;
 841                 }
 842
 843                 sb->s_flags |= SB_ACTIVE;
 844         }
 845
 846         root = cifs_get_root(volume_info, sb);
 847         if (IS_ERR(root))
 848                 goto out_super;
 849
 850         cifs_dbg(FYI, "dentry root is: %p\n", root);
 851         goto out;
 852
 853 out_super:
 854         deactivate_locked_super(sb);
 855 out:
 856         cifs_cleanup_volume_info(volume_info);
 857         return root;
 858
 859 out_free:
 860         kfree(cifs_sb->prepath);
 861         kfree(cifs_sb->mountdata);
 862         kfree(cifs_sb);
 863 out_nls:
 864         unload_nls(volume_info->local_nls);
 865         goto out;
 866 }
 867
 868 static struct dentry *
 869 smb3_do_mount(struct file_system_type *fs_type,
 870               int flags, const char *dev_name, void *data)
 871 {
 872         return cifs_smb3_do_mount(fs_type, flags, dev_name, data, true);
 873 }
 874
 875 static struct dentry *
 876 cifs_do_mount(struct file_system_type *fs_type,
 877               int flags, const char *dev_name, void *data)
 878 {
 879         return cifs_smb3_do_mount(fs_type, flags, dev_name, data, false);
 880 }
 881
 882 static ssize_t
 883 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
 884 {
 885         ssize_t rc;
 886         struct inode *inode = file_inode(iocb->ki_filp);
 887
 888         if (iocb->ki_filp->f_flags & O_DIRECT)
 889                 return cifs_user_readv(iocb, iter);
 890
 891         rc = cifs_revalidate_mapping(inode);
 892         if (rc)
 893                 return rc;
 894
 895         return generic_file_read_iter(iocb, iter);
 896 }
 897
 898 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 899 {
 900         struct inode *inode = file_inode(iocb->ki_filp);
 901         struct cifsInodeInfo *cinode = CIFS_I(inode);
 902         ssize_t written;
 903         int rc;
 904
 905         if (iocb->ki_filp->f_flags & O_DIRECT) {
 906                 written = cifs_user_writev(iocb, from);
 907                 if (written > 0 && CIFS_CACHE_READ(cinode)) {
 908                         cifs_zap_mapping(inode);
 909                         cifs_dbg(FYI,
 910                                  "Set no oplock for inode=%p after a write operation\n",
 911                                  inode);
 912                         cinode->oplock = 0;
 913                 }
 914                 return written;
 915         }
 916
 917         written = cifs_get_writer(cinode);
 918         if (written)
 919                 return written;
 920
 921         written = generic_file_write_iter(iocb, from);
 922
 923         if (CIFS_CACHE_WRITE(CIFS_I(inode)))
 924                 goto out;
 925
 926         rc = filemap_fdatawrite(inode->i_mapping);
 927         if (rc)
 928                 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
 929                          rc, inode);
 930
 931 out:
 932         cifs_put_writer(cinode);
 933         return written;
 934 }
 935
 936 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
 937 {
 938         struct cifsFileInfo *cfile = file->private_data;
 939         struct cifs_tcon *tcon;
 940
 941         /*
 942          * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
 943          * the cached file length
 944          */
 945         if (whence != SEEK_SET && whence != SEEK_CUR) {
 946                 int rc;
 947                 struct inode *inode = file_inode(file);
 948
 949                 /*
 950                  * We need to be sure that all dirty pages are written and the
 951                  * server has the newest file length.
 952                  */
 953                 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
 954                     inode->i_mapping->nrpages != 0) {
 955                         rc = filemap_fdatawait(inode->i_mapping);
 956                         if (rc) {
 957                                 mapping_set_error(inode->i_mapping, rc);
 958                                 return rc;
 959                         }
 960                 }
 961                 /*
 962                  * Some applications poll for the file length in this strange
 963                  * way so we must seek to end on non-oplocked files by
 964                  * setting the revalidate time to zero.
 965                  */
 966                 CIFS_I(inode)->time = 0;
 967
 968                 rc = cifs_revalidate_file_attr(file);
 969                 if (rc < 0)
 970                         return (loff_t)rc;
 971         }
 972         if (cfile && cfile->tlink) {
 973                 tcon = tlink_tcon(cfile->tlink);
 974                 if (tcon->ses->server->ops->llseek)
 975                         return tcon->ses->server->ops->llseek(file, tcon,
 976                                                               offset, whence);
 977         }
 978         return generic_file_llseek(file, offset, whence);
 979 }
 980
 981 static int
 982 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
 983 {
 984         /*
 985          * Note that this is called by vfs setlease with i_lock held to
 986          * protect *lease from going away.
 987          */
 988         struct inode *inode = file_inode(file);
 989         struct cifsFileInfo *cfile = file->private_data;
 990
 991         if (!(S_ISREG(inode->i_mode)))
 992                 return -EINVAL;
 993
 994         /* Check if file is oplocked if this is request for new lease */
 995         if (arg == F_UNLCK ||
 996             ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
 997             ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
 998                 return generic_setlease(file, arg, lease, priv);
 999         else if (tlink_tcon(cfile->tlink)->local_lease &&
1000                  !CIFS_CACHE_READ(CIFS_I(inode)))
1001                 /*
1002                  * If the server claims to support oplock on this file, then we
1003                  * still need to check oplock even if the local_lease mount
1004                  * option is set, but there are servers which do not support
1005                  * oplock for which this mount option may be useful if the user
1006                  * knows that the file won't be changed on the server by anyone
1007                  * else.
1008                  */
1009                 return generic_setlease(file, arg, lease, priv);
1010         else
1011                 return -EAGAIN;
1012 }
1013
1014 struct file_system_type cifs_fs_type = {
1015         .owner = THIS_MODULE,
1016         .name = "cifs",
1017         .mount = cifs_do_mount,
1018         .kill_sb = cifs_kill_sb,
1019         /*  .fs_flags */
1020 };
1021 MODULE_ALIAS_FS("cifs");
1022
1023 static struct file_system_type smb3_fs_type = {
1024         .owner = THIS_MODULE,
1025         .name = "smb3",
1026         .mount = smb3_do_mount,
1027         .kill_sb = cifs_kill_sb,
1028         /*  .fs_flags */
1029 };
1030 MODULE_ALIAS_FS("smb3");
1031 MODULE_ALIAS("smb3");
1032
1033 const struct inode_operations cifs_dir_inode_ops = {
1034         .create = cifs_create,
1035         .atomic_open = cifs_atomic_open,
1036         .lookup = cifs_lookup,
1037         .getattr = cifs_getattr,
1038         .unlink = cifs_unlink,
1039         .link = cifs_hardlink,
1040         .mkdir = cifs_mkdir,
1041         .rmdir = cifs_rmdir,
1042         .rename = cifs_rename2,
1043         .permission = cifs_permission,
1044         .setattr = cifs_setattr,
1045         .symlink = cifs_symlink,
1046         .mknod   = cifs_mknod,
1047         .listxattr = cifs_listxattr,
1048 };
1049
1050 const struct inode_operations cifs_file_inode_ops = {
1051         .setattr = cifs_setattr,
1052         .getattr = cifs_getattr,
1053         .permission = cifs_permission,
1054         .listxattr = cifs_listxattr,
1055         .fiemap = cifs_fiemap,
1056 };
1057
1058 const struct inode_operations cifs_symlink_inode_ops = {
1059         .get_link = cifs_get_link,
1060         .permission = cifs_permission,
1061         .listxattr = cifs_listxattr,
1062 };
1063
1064 static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,
1065                 struct file *dst_file, loff_t destoff, loff_t len,
1066                 unsigned int remap_flags)
1067 {
1068         struct inode *src_inode = file_inode(src_file);
1069         struct inode *target_inode = file_inode(dst_file);
1070         struct cifsFileInfo *smb_file_src = src_file->private_data;
1071         struct cifsFileInfo *smb_file_target;
1072         struct cifs_tcon *target_tcon;
1073         unsigned int xid;
1074         int rc;
1075
1076         if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY))
1077                 return -EINVAL;
1078
1079         cifs_dbg(FYI, "clone range\n");
1080
1081         xid = get_xid();
1082
1083         if (!src_file->private_data || !dst_file->private_data) {
1084                 rc = -EBADF;
1085                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1086                 goto out;
1087         }
1088
1089         smb_file_target = dst_file->private_data;
1090         target_tcon = tlink_tcon(smb_file_target->tlink);
1091
1092         /*
1093          * Note: cifs case is easier than btrfs since server responsible for
1094          * checks for proper open modes and file type and if it wants
1095          * server could even support copy of range where source = target
1096          */
1097         lock_two_nondirectories(target_inode, src_inode);
1098
1099         if (len == 0)
1100                 len = src_inode->i_size - off;
1101
1102         cifs_dbg(FYI, "about to flush pages\n");
1103         /* should we flush first and last page first */
1104         truncate_inode_pages_range(&target_inode->i_data, destoff,
1105                                    PAGE_ALIGN(destoff + len)-1);
1106
1107         if (target_tcon->ses->server->ops->duplicate_extents)
1108                 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
1109                         smb_file_src, smb_file_target, off, len, destoff);
1110         else
1111                 rc = -EOPNOTSUPP;
1112
1113         /* force revalidate of size and timestamps of target file now
1114            that target is updated on the server */
1115         CIFS_I(target_inode)->time = 0;
1116         /* although unlocking in the reverse order from locking is not
1117            strictly necessary here it is a little cleaner to be consistent */
1118         unlock_two_nondirectories(src_inode, target_inode);
1119 out:
1120         free_xid(xid);
1121         return rc < 0 ? rc : len;
1122 }
1123
1124 ssize_t cifs_file_copychunk_range(unsigned int xid,
1125                                 struct file *src_file, loff_t off,
1126                                 struct file *dst_file, loff_t destoff,
1127                                 size_t len, unsigned int flags)
1128 {
1129         struct inode *src_inode = file_inode(src_file);
1130         struct inode *target_inode = file_inode(dst_file);
1131         struct cifsFileInfo *smb_file_src;
1132         struct cifsFileInfo *smb_file_target;
1133         struct cifs_tcon *src_tcon;
1134         struct cifs_tcon *target_tcon;
1135         ssize_t rc;
1136
1137         cifs_dbg(FYI, "copychunk range\n");
1138
1139         if (!src_file->private_data || !dst_file->private_data) {
1140                 rc = -EBADF;
1141                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1142                 goto out;
1143         }
1144
1145         rc = -EXDEV;
1146         smb_file_target = dst_file->private_data;
1147         smb_file_src = src_file->private_data;
1148         src_tcon = tlink_tcon(smb_file_src->tlink);
1149         target_tcon = tlink_tcon(smb_file_target->tlink);
1150
1151         if (src_tcon->ses != target_tcon->ses) {
1152                 cifs_dbg(VFS, "source and target of copy not on same server\n");
1153                 goto out;
1154         }
1155
1156         rc = -EOPNOTSUPP;
1157         if (!target_tcon->ses->server->ops->copychunk_range)
1158                 goto out;
1159
1160         /*
1161          * Note: cifs case is easier than btrfs since server responsible for
1162          * checks for proper open modes and file type and if it wants
1163          * server could even support copy of range where source = target
1164          */
1165         lock_two_nondirectories(target_inode, src_inode);
1166
1167         cifs_dbg(FYI, "about to flush pages\n");
1168         /* should we flush first and last page first */
1169         truncate_inode_pages(&target_inode->i_data, 0);
1170
1171         rc = file_modified(dst_file);
1172         if (!rc)
1173                 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1174                         smb_file_src, smb_file_target, off, len, destoff);
1175
1176         file_accessed(src_file);
1177
1178         /* force revalidate of size and timestamps of target file now
1179          * that target is updated on the server
1180          */
1181         CIFS_I(target_inode)->time = 0;
1182         /* although unlocking in the reverse order from locking is not
1183          * strictly necessary here it is a little cleaner to be consistent
1184          */
1185         unlock_two_nondirectories(src_inode, target_inode);
1186
1187 out:
1188         return rc;
1189 }
1190
1191 /*
1192  * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1193  * is a dummy operation.
1194  */
1195 static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1196 {
1197         cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1198                  file, datasync);
1199
1200         return 0;
1201 }
1202
1203 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1204                                 struct file *dst_file, loff_t destoff,
1205                                 size_t len, unsigned int flags)
1206 {
1207         unsigned int xid = get_xid();
1208         ssize_t rc;
1209
1210         rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1211                                         len, flags);
1212         free_xid(xid);
1213
1214         if (rc == -EOPNOTSUPP || rc == -EXDEV)
1215                 rc = generic_copy_file_range(src_file, off, dst_file,
1216                                              destoff, len, flags);
1217         return rc;
1218 }
1219
1220 const struct file_operations cifs_file_ops = {
1221         .read_iter = cifs_loose_read_iter,
1222         .write_iter = cifs_file_write_iter,
1223         .open = cifs_open,
1224         .release = cifs_close,
1225         .lock = cifs_lock,
1226         .flock = cifs_flock,
1227         .fsync = cifs_fsync,
1228         .flush = cifs_flush,
1229         .mmap  = cifs_file_mmap,
1230         .splice_read = generic_file_splice_read,
1231         .splice_write = iter_file_splice_write,
1232         .llseek = cifs_llseek,
1233         .unlocked_ioctl = cifs_ioctl,
1234         .copy_file_range = cifs_copy_file_range,
1235         .remap_file_range = cifs_remap_file_range,
1236         .setlease = cifs_setlease,
1237         .fallocate = cifs_fallocate,
1238 };
1239
1240 const struct file_operations cifs_file_strict_ops = {
1241         .read_iter = cifs_strict_readv,
1242         .write_iter = cifs_strict_writev,
1243         .open = cifs_open,
1244         .release = cifs_close,
1245         .lock = cifs_lock,
1246         .flock = cifs_flock,
1247         .fsync = cifs_strict_fsync,
1248         .flush = cifs_flush,
1249         .mmap = cifs_file_strict_mmap,
1250         .splice_read = generic_file_splice_read,
1251         .splice_write = iter_file_splice_write,
1252         .llseek = cifs_llseek,
1253         .unlocked_ioctl = cifs_ioctl,
1254         .copy_file_range = cifs_copy_file_range,
1255         .remap_file_range = cifs_remap_file_range,
1256         .setlease = cifs_setlease,
1257         .fallocate = cifs_fallocate,
1258 };
1259
1260 const struct file_operations cifs_file_direct_ops = {
1261         .read_iter = cifs_direct_readv,
1262         .write_iter = cifs_direct_writev,
1263         .open = cifs_open,
1264         .release = cifs_close,
1265         .lock = cifs_lock,
1266         .flock = cifs_flock,
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         cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1565                                          WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1566         if (!cifsoplockd_wq) {
1567                 rc = -ENOMEM;
1568                 goto out_destroy_decrypt_wq;
1569         }
1570
1571         rc = cifs_fscache_register();
1572         if (rc)
1573                 goto out_destroy_cifsoplockd_wq;
1574
1575         rc = cifs_init_inodecache();
1576         if (rc)
1577                 goto out_unreg_fscache;
1578
1579         rc = cifs_init_mids();
1580         if (rc)
1581                 goto out_destroy_inodecache;
1582
1583         rc = cifs_init_request_bufs();
1584         if (rc)
1585                 goto out_destroy_mids;
1586
1587 #ifdef CONFIG_CIFS_DFS_UPCALL
1588         rc = dfs_cache_init();
1589         if (rc)
1590                 goto out_destroy_request_bufs;
1591 #endif /* CONFIG_CIFS_DFS_UPCALL */
1592 #ifdef CONFIG_CIFS_UPCALL
1593         rc = init_cifs_spnego();
1594         if (rc)
1595                 goto out_destroy_dfs_cache;
1596 #endif /* CONFIG_CIFS_UPCALL */
1597
1598         rc = init_cifs_idmap();
1599         if (rc)
1600                 goto out_register_key_type;
1601
1602         rc = register_filesystem(&cifs_fs_type);
1603         if (rc)
1604                 goto out_init_cifs_idmap;
1605
1606         rc = register_filesystem(&smb3_fs_type);
1607         if (rc) {
1608                 unregister_filesystem(&cifs_fs_type);
1609                 goto out_init_cifs_idmap;
1610         }
1611
1612         return 0;
1613
1614 out_init_cifs_idmap:
1615         exit_cifs_idmap();
1616 out_register_key_type:
1617 #ifdef CONFIG_CIFS_UPCALL
1618         exit_cifs_spnego();
1619 out_destroy_dfs_cache:
1620 #endif
1621 #ifdef CONFIG_CIFS_DFS_UPCALL
1622         dfs_cache_destroy();
1623 out_destroy_request_bufs:
1624 #endif
1625         cifs_destroy_request_bufs();
1626 out_destroy_mids:
1627         cifs_destroy_mids();
1628 out_destroy_inodecache:
1629         cifs_destroy_inodecache();
1630 out_unreg_fscache:
1631         cifs_fscache_unregister();
1632 out_destroy_cifsoplockd_wq:
1633         destroy_workqueue(cifsoplockd_wq);
1634 out_destroy_decrypt_wq:
1635         destroy_workqueue(decrypt_wq);
1636 out_destroy_cifsiod_wq:
1637         destroy_workqueue(cifsiod_wq);
1638 out_clean_proc:
1639         cifs_proc_clean();
1640         return rc;
1641 }
1642
1643 static void __exit
1644 exit_cifs(void)
1645 {
1646         cifs_dbg(NOISY, "exit_smb3\n");
1647         unregister_filesystem(&cifs_fs_type);
1648         unregister_filesystem(&smb3_fs_type);
1649         cifs_dfs_release_automount_timer();
1650         exit_cifs_idmap();
1651 #ifdef CONFIG_CIFS_UPCALL
1652         exit_cifs_spnego();
1653 #endif
1654 #ifdef CONFIG_CIFS_DFS_UPCALL
1655         dfs_cache_destroy();
1656 #endif
1657         cifs_destroy_request_bufs();
1658         cifs_destroy_mids();
1659         cifs_destroy_inodecache();
1660         cifs_fscache_unregister();
1661         destroy_workqueue(cifsoplockd_wq);
1662         destroy_workqueue(decrypt_wq);
1663         destroy_workqueue(cifsiod_wq);
1664         cifs_proc_clean();
1665 }
1666
1667 MODULE_AUTHOR("Steve French");
1668 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1669 MODULE_DESCRIPTION
1670         ("VFS to access SMB3 servers e.g. Samba, Macs, Azure and Windows (and "
1671         "also older servers complying with the SNIA CIFS Specification)");
1672 MODULE_VERSION(CIFS_VERSION);
1673 MODULE_SOFTDEP("ecb");
1674 MODULE_SOFTDEP("hmac");
1675 MODULE_SOFTDEP("md4");
1676 MODULE_SOFTDEP("md5");
1677 MODULE_SOFTDEP("nls");
1678 MODULE_SOFTDEP("aes");
1679 MODULE_SOFTDEP("cmac");
1680 MODULE_SOFTDEP("sha256");
1681 MODULE_SOFTDEP("sha512");
1682 MODULE_SOFTDEP("aead2");
1683 MODULE_SOFTDEP("ccm");
1684 MODULE_SOFTDEP("gcm");
1685 module_init(init_cifs)
1686 module_exit(exit_cifs)