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