fs/cifs/cifsfs.c

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