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 (sfrench@us.ibm.com)
   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         return root;
 923 out:
 924         if (cifs_sb) {
 925                 kfree(cifs_sb->prepath);
 926                 smb3_cleanup_fs_context(cifs_sb->ctx);
 927                 kfree(cifs_sb);
 928         }
 929         return root;
 930 }
 931
 932
 933 static ssize_t
 934 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
 935 {
 936         ssize_t rc;
 937         struct inode *inode = file_inode(iocb->ki_filp);
 938
 939         if (iocb->ki_filp->f_flags & O_DIRECT)
 940                 return cifs_user_readv(iocb, iter);
 941
 942         rc = cifs_revalidate_mapping(inode);
 943         if (rc)
 944                 return rc;
 945
 946         return generic_file_read_iter(iocb, iter);
 947 }
 948
 949 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 950 {
 951         struct inode *inode = file_inode(iocb->ki_filp);
 952         struct cifsInodeInfo *cinode = CIFS_I(inode);
 953         ssize_t written;
 954         int rc;
 955
 956         if (iocb->ki_filp->f_flags & O_DIRECT) {
 957                 written = cifs_user_writev(iocb, from);
 958                 if (written > 0 && CIFS_CACHE_READ(cinode)) {
 959                         cifs_zap_mapping(inode);
 960                         cifs_dbg(FYI,
 961                                  "Set no oplock for inode=%p after a write operation\n",
 962                                  inode);
 963                         cinode->oplock = 0;
 964                 }
 965                 return written;
 966         }
 967
 968         written = cifs_get_writer(cinode);
 969         if (written)
 970                 return written;
 971
 972         written = generic_file_write_iter(iocb, from);
 973
 974         if (CIFS_CACHE_WRITE(CIFS_I(inode)))
 975                 goto out;
 976
 977         rc = filemap_fdatawrite(inode->i_mapping);
 978         if (rc)
 979                 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
 980                          rc, inode);
 981
 982 out:
 983         cifs_put_writer(cinode);
 984         return written;
 985 }
 986
 987 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
 988 {
 989         struct cifsFileInfo *cfile = file->private_data;
 990         struct cifs_tcon *tcon;
 991
 992         /*
 993          * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
 994          * the cached file length
 995          */
 996         if (whence != SEEK_SET && whence != SEEK_CUR) {
 997                 int rc;
 998                 struct inode *inode = file_inode(file);
 999
1000                 /*
1001                  * We need to be sure that all dirty pages are written and the
1002                  * server has the newest file length.
1003                  */
1004                 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1005                     inode->i_mapping->nrpages != 0) {
1006                         rc = filemap_fdatawait(inode->i_mapping);
1007                         if (rc) {
1008                                 mapping_set_error(inode->i_mapping, rc);
1009                                 return rc;
1010                         }
1011                 }
1012                 /*
1013                  * Some applications poll for the file length in this strange
1014                  * way so we must seek to end on non-oplocked files by
1015                  * setting the revalidate time to zero.
1016                  */
1017                 CIFS_I(inode)->time = 0;
1018
1019                 rc = cifs_revalidate_file_attr(file);
1020                 if (rc < 0)
1021                         return (loff_t)rc;
1022         }
1023         if (cfile && cfile->tlink) {
1024                 tcon = tlink_tcon(cfile->tlink);
1025                 if (tcon->ses->server->ops->llseek)
1026                         return tcon->ses->server->ops->llseek(file, tcon,
1027                                                               offset, whence);
1028         }
1029         return generic_file_llseek(file, offset, whence);
1030 }
1031
1032 static int
1033 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
1034 {
1035         /*
1036          * Note that this is called by vfs setlease with i_lock held to
1037          * protect *lease from going away.
1038          */
1039         struct inode *inode = file_inode(file);
1040         struct cifsFileInfo *cfile = file->private_data;
1041
1042         if (!(S_ISREG(inode->i_mode)))
1043                 return -EINVAL;
1044
1045         /* Check if file is oplocked if this is request for new lease */
1046         if (arg == F_UNLCK ||
1047             ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
1048             ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
1049                 return generic_setlease(file, arg, lease, priv);
1050         else if (tlink_tcon(cfile->tlink)->local_lease &&
1051                  !CIFS_CACHE_READ(CIFS_I(inode)))
1052                 /*
1053                  * If the server claims to support oplock on this file, then we
1054                  * still need to check oplock even if the local_lease mount
1055                  * option is set, but there are servers which do not support
1056                  * oplock for which this mount option may be useful if the user
1057                  * knows that the file won't be changed on the server by anyone
1058                  * else.
1059                  */
1060                 return generic_setlease(file, arg, lease, priv);
1061         else
1062                 return -EAGAIN;
1063 }
1064
1065 struct file_system_type cifs_fs_type = {
1066         .owner = THIS_MODULE,
1067         .name = "cifs",
1068         .init_fs_context = smb3_init_fs_context,
1069         .parameters = smb3_fs_parameters,
1070         .kill_sb = cifs_kill_sb,
1071         .fs_flags = FS_RENAME_DOES_D_MOVE,
1072 };
1073 MODULE_ALIAS_FS("cifs");
1074
1075 static struct file_system_type smb3_fs_type = {
1076         .owner = THIS_MODULE,
1077         .name = "smb3",
1078         .init_fs_context = smb3_init_fs_context,
1079         .parameters = smb3_fs_parameters,
1080         .kill_sb = cifs_kill_sb,
1081         .fs_flags = FS_RENAME_DOES_D_MOVE,
1082 };
1083 MODULE_ALIAS_FS("smb3");
1084 MODULE_ALIAS("smb3");
1085
1086 const struct inode_operations cifs_dir_inode_ops = {
1087         .create = cifs_create,
1088         .atomic_open = cifs_atomic_open,
1089         .lookup = cifs_lookup,
1090         .getattr = cifs_getattr,
1091         .unlink = cifs_unlink,
1092         .link = cifs_hardlink,
1093         .mkdir = cifs_mkdir,
1094         .rmdir = cifs_rmdir,
1095         .rename = cifs_rename2,
1096         .permission = cifs_permission,
1097         .setattr = cifs_setattr,
1098         .symlink = cifs_symlink,
1099         .mknod   = cifs_mknod,
1100         .listxattr = cifs_listxattr,
1101 };
1102
1103 const struct inode_operations cifs_file_inode_ops = {
1104         .setattr = cifs_setattr,
1105         .getattr = cifs_getattr,
1106         .permission = cifs_permission,
1107         .listxattr = cifs_listxattr,
1108         .fiemap = cifs_fiemap,
1109 };
1110
1111 const struct inode_operations cifs_symlink_inode_ops = {
1112         .get_link = cifs_get_link,
1113         .permission = cifs_permission,
1114         .listxattr = cifs_listxattr,
1115 };
1116
1117 static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,
1118                 struct file *dst_file, loff_t destoff, loff_t len,
1119                 unsigned int remap_flags)
1120 {
1121         struct inode *src_inode = file_inode(src_file);
1122         struct inode *target_inode = file_inode(dst_file);
1123         struct cifsFileInfo *smb_file_src = src_file->private_data;
1124         struct cifsFileInfo *smb_file_target;
1125         struct cifs_tcon *target_tcon;
1126         unsigned int xid;
1127         int rc;
1128
1129         if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY))
1130                 return -EINVAL;
1131
1132         cifs_dbg(FYI, "clone range\n");
1133
1134         xid = get_xid();
1135
1136         if (!src_file->private_data || !dst_file->private_data) {
1137                 rc = -EBADF;
1138                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1139                 goto out;
1140         }
1141
1142         smb_file_target = dst_file->private_data;
1143         target_tcon = tlink_tcon(smb_file_target->tlink);
1144
1145         /*
1146          * Note: cifs case is easier than btrfs since server responsible for
1147          * checks for proper open modes and file type and if it wants
1148          * server could even support copy of range where source = target
1149          */
1150         lock_two_nondirectories(target_inode, src_inode);
1151
1152         if (len == 0)
1153                 len = src_inode->i_size - off;
1154
1155         cifs_dbg(FYI, "about to flush pages\n");
1156         /* should we flush first and last page first */
1157         truncate_inode_pages_range(&target_inode->i_data, destoff,
1158                                    PAGE_ALIGN(destoff + len)-1);
1159
1160         if (target_tcon->ses->server->ops->duplicate_extents)
1161                 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
1162                         smb_file_src, smb_file_target, off, len, destoff);
1163         else
1164                 rc = -EOPNOTSUPP;
1165
1166         /* force revalidate of size and timestamps of target file now
1167            that target is updated on the server */
1168         CIFS_I(target_inode)->time = 0;
1169         /* although unlocking in the reverse order from locking is not
1170            strictly necessary here it is a little cleaner to be consistent */
1171         unlock_two_nondirectories(src_inode, target_inode);
1172 out:
1173         free_xid(xid);
1174         return rc < 0 ? rc : len;
1175 }
1176
1177 ssize_t cifs_file_copychunk_range(unsigned int xid,
1178                                 struct file *src_file, loff_t off,
1179                                 struct file *dst_file, loff_t destoff,
1180                                 size_t len, unsigned int flags)
1181 {
1182         struct inode *src_inode = file_inode(src_file);
1183         struct inode *target_inode = file_inode(dst_file);
1184         struct cifsFileInfo *smb_file_src;
1185         struct cifsFileInfo *smb_file_target;
1186         struct cifs_tcon *src_tcon;
1187         struct cifs_tcon *target_tcon;
1188         ssize_t rc;
1189
1190         cifs_dbg(FYI, "copychunk range\n");
1191
1192         if (!src_file->private_data || !dst_file->private_data) {
1193                 rc = -EBADF;
1194                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1195                 goto out;
1196         }
1197
1198         rc = -EXDEV;
1199         smb_file_target = dst_file->private_data;
1200         smb_file_src = src_file->private_data;
1201         src_tcon = tlink_tcon(smb_file_src->tlink);
1202         target_tcon = tlink_tcon(smb_file_target->tlink);
1203
1204         if (src_tcon->ses != target_tcon->ses) {
1205                 cifs_dbg(VFS, "source and target of copy not on same server\n");
1206                 goto out;
1207         }
1208
1209         rc = -EOPNOTSUPP;
1210         if (!target_tcon->ses->server->ops->copychunk_range)
1211                 goto out;
1212
1213         /*
1214          * Note: cifs case is easier than btrfs since server responsible for
1215          * checks for proper open modes and file type and if it wants
1216          * server could even support copy of range where source = target
1217          */
1218         lock_two_nondirectories(target_inode, src_inode);
1219
1220         cifs_dbg(FYI, "about to flush pages\n");
1221         /* should we flush first and last page first */
1222         truncate_inode_pages(&target_inode->i_data, 0);
1223
1224         rc = file_modified(dst_file);
1225         if (!rc)
1226                 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1227                         smb_file_src, smb_file_target, off, len, destoff);
1228
1229         file_accessed(src_file);
1230
1231         /* force revalidate of size and timestamps of target file now
1232          * that target is updated on the server
1233          */
1234         CIFS_I(target_inode)->time = 0;
1235         /* although unlocking in the reverse order from locking is not
1236          * strictly necessary here it is a little cleaner to be consistent
1237          */
1238         unlock_two_nondirectories(src_inode, target_inode);
1239
1240 out:
1241         return rc;
1242 }
1243
1244 /*
1245  * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1246  * is a dummy operation.
1247  */
1248 static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1249 {
1250         cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1251                  file, datasync);
1252
1253         return 0;
1254 }
1255
1256 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1257                                 struct file *dst_file, loff_t destoff,
1258                                 size_t len, unsigned int flags)
1259 {
1260         unsigned int xid = get_xid();
1261         ssize_t rc;
1262         struct cifsFileInfo *cfile = dst_file->private_data;
1263
1264         if (cfile->swapfile)
1265                 return -EOPNOTSUPP;
1266
1267         rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1268                                         len, flags);
1269         free_xid(xid);
1270
1271         if (rc == -EOPNOTSUPP || rc == -EXDEV)
1272                 rc = generic_copy_file_range(src_file, off, dst_file,
1273                                              destoff, len, flags);
1274         return rc;
1275 }
1276
1277 const struct file_operations cifs_file_ops = {
1278         .read_iter = cifs_loose_read_iter,
1279         .write_iter = cifs_file_write_iter,
1280         .open = cifs_open,
1281         .release = cifs_close,
1282         .lock = cifs_lock,
1283         .flock = cifs_flock,
1284         .fsync = cifs_fsync,
1285         .flush = cifs_flush,
1286         .mmap  = cifs_file_mmap,
1287         .splice_read = generic_file_splice_read,
1288         .splice_write = iter_file_splice_write,
1289         .llseek = cifs_llseek,
1290         .unlocked_ioctl = cifs_ioctl,
1291         .copy_file_range = cifs_copy_file_range,
1292         .remap_file_range = cifs_remap_file_range,
1293         .setlease = cifs_setlease,
1294         .fallocate = cifs_fallocate,
1295 };
1296
1297 const struct file_operations cifs_file_strict_ops = {
1298         .read_iter = cifs_strict_readv,
1299         .write_iter = cifs_strict_writev,
1300         .open = cifs_open,
1301         .release = cifs_close,
1302         .lock = cifs_lock,
1303         .flock = cifs_flock,
1304         .fsync = cifs_strict_fsync,
1305         .flush = cifs_flush,
1306         .mmap = cifs_file_strict_mmap,
1307         .splice_read = generic_file_splice_read,
1308         .splice_write = iter_file_splice_write,
1309         .llseek = cifs_llseek,
1310         .unlocked_ioctl = cifs_ioctl,
1311         .copy_file_range = cifs_copy_file_range,
1312         .remap_file_range = cifs_remap_file_range,
1313         .setlease = cifs_setlease,
1314         .fallocate = cifs_fallocate,
1315 };
1316
1317 const struct file_operations cifs_file_direct_ops = {
1318         .read_iter = cifs_direct_readv,
1319         .write_iter = cifs_direct_writev,
1320         .open = cifs_open,
1321         .release = cifs_close,
1322         .lock = cifs_lock,
1323         .flock = cifs_flock,
1324         .fsync = cifs_fsync,
1325         .flush = cifs_flush,
1326         .mmap = cifs_file_mmap,
1327         .splice_read = generic_file_splice_read,
1328         .splice_write = iter_file_splice_write,
1329         .unlocked_ioctl  = cifs_ioctl,
1330         .copy_file_range = cifs_copy_file_range,
1331         .remap_file_range = cifs_remap_file_range,
1332         .llseek = cifs_llseek,
1333         .setlease = cifs_setlease,
1334         .fallocate = cifs_fallocate,
1335 };
1336
1337 const struct file_operations cifs_file_nobrl_ops = {
1338         .read_iter = cifs_loose_read_iter,
1339         .write_iter = cifs_file_write_iter,
1340         .open = cifs_open,
1341         .release = cifs_close,
1342         .fsync = cifs_fsync,
1343         .flush = cifs_flush,
1344         .mmap  = cifs_file_mmap,
1345         .splice_read = generic_file_splice_read,
1346         .splice_write = iter_file_splice_write,
1347         .llseek = cifs_llseek,
1348         .unlocked_ioctl = cifs_ioctl,
1349         .copy_file_range = cifs_copy_file_range,
1350         .remap_file_range = cifs_remap_file_range,
1351         .setlease = cifs_setlease,
1352         .fallocate = cifs_fallocate,
1353 };
1354
1355 const struct file_operations cifs_file_strict_nobrl_ops = {
1356         .read_iter = cifs_strict_readv,
1357         .write_iter = cifs_strict_writev,
1358         .open = cifs_open,
1359         .release = cifs_close,
1360         .fsync = cifs_strict_fsync,
1361         .flush = cifs_flush,
1362         .mmap = cifs_file_strict_mmap,
1363         .splice_read = generic_file_splice_read,
1364         .splice_write = iter_file_splice_write,
1365         .llseek = cifs_llseek,
1366         .unlocked_ioctl = cifs_ioctl,
1367         .copy_file_range = cifs_copy_file_range,
1368         .remap_file_range = cifs_remap_file_range,
1369         .setlease = cifs_setlease,
1370         .fallocate = cifs_fallocate,
1371 };
1372
1373 const struct file_operations cifs_file_direct_nobrl_ops = {
1374         .read_iter = cifs_direct_readv,
1375         .write_iter = cifs_direct_writev,
1376         .open = cifs_open,
1377         .release = cifs_close,
1378         .fsync = cifs_fsync,
1379         .flush = cifs_flush,
1380         .mmap = cifs_file_mmap,
1381         .splice_read = generic_file_splice_read,
1382         .splice_write = iter_file_splice_write,
1383         .unlocked_ioctl  = cifs_ioctl,
1384         .copy_file_range = cifs_copy_file_range,
1385         .remap_file_range = cifs_remap_file_range,
1386         .llseek = cifs_llseek,
1387         .setlease = cifs_setlease,
1388         .fallocate = cifs_fallocate,
1389 };
1390
1391 const struct file_operations cifs_dir_ops = {
1392         .iterate_shared = cifs_readdir,
1393         .release = cifs_closedir,
1394         .read    = generic_read_dir,
1395         .unlocked_ioctl  = cifs_ioctl,
1396         .copy_file_range = cifs_copy_file_range,
1397         .remap_file_range = cifs_remap_file_range,
1398         .llseek = generic_file_llseek,
1399         .fsync = cifs_dir_fsync,
1400 };
1401
1402 static void
1403 cifs_init_once(void *inode)
1404 {
1405         struct cifsInodeInfo *cifsi = inode;
1406
1407         inode_init_once(&cifsi->vfs_inode);
1408         init_rwsem(&cifsi->lock_sem);
1409 }
1410
1411 static int __init
1412 cifs_init_inodecache(void)
1413 {
1414         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1415                                               sizeof(struct cifsInodeInfo),
1416                                               0, (SLAB_RECLAIM_ACCOUNT|
1417                                                 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1418                                               cifs_init_once);
1419         if (cifs_inode_cachep == NULL)
1420                 return -ENOMEM;
1421
1422         return 0;
1423 }
1424
1425 static void
1426 cifs_destroy_inodecache(void)
1427 {
1428         /*
1429          * Make sure all delayed rcu free inodes are flushed before we
1430          * destroy cache.
1431          */
1432         rcu_barrier();
1433         kmem_cache_destroy(cifs_inode_cachep);
1434 }
1435
1436 static int
1437 cifs_init_request_bufs(void)
1438 {
1439         /*
1440          * SMB2 maximum header size is bigger than CIFS one - no problems to
1441          * allocate some more bytes for CIFS.
1442          */
1443         size_t max_hdr_size = MAX_SMB2_HDR_SIZE;
1444
1445         if (CIFSMaxBufSize < 8192) {
1446         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1447         Unicode path name has to fit in any SMB/CIFS path based frames */
1448                 CIFSMaxBufSize = 8192;
1449         } else if (CIFSMaxBufSize > 1024*127) {
1450                 CIFSMaxBufSize = 1024 * 127;
1451         } else {
1452                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1453         }
1454 /*
1455         cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1456                  CIFSMaxBufSize, CIFSMaxBufSize);
1457 */
1458         cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",
1459                                             CIFSMaxBufSize + max_hdr_size, 0,
1460                                             SLAB_HWCACHE_ALIGN, 0,
1461                                             CIFSMaxBufSize + max_hdr_size,
1462                                             NULL);
1463         if (cifs_req_cachep == NULL)
1464                 return -ENOMEM;
1465
1466         if (cifs_min_rcv < 1)
1467                 cifs_min_rcv = 1;
1468         else if (cifs_min_rcv > 64) {
1469                 cifs_min_rcv = 64;
1470                 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1471         }
1472
1473         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1474                                                   cifs_req_cachep);
1475
1476         if (cifs_req_poolp == NULL) {
1477                 kmem_cache_destroy(cifs_req_cachep);
1478                 return -ENOMEM;
1479         }
1480         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1481         almost all handle based requests (but not write response, nor is it
1482         sufficient for path based requests).  A smaller size would have
1483         been more efficient (compacting multiple slab items on one 4k page)
1484         for the case in which debug was on, but this larger size allows
1485         more SMBs to use small buffer alloc and is still much more
1486         efficient to alloc 1 per page off the slab compared to 17K (5page)
1487         alloc of large cifs buffers even when page debugging is on */
1488         cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",
1489                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1490                         0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);
1491         if (cifs_sm_req_cachep == NULL) {
1492                 mempool_destroy(cifs_req_poolp);
1493                 kmem_cache_destroy(cifs_req_cachep);
1494                 return -ENOMEM;
1495         }
1496
1497         if (cifs_min_small < 2)
1498                 cifs_min_small = 2;
1499         else if (cifs_min_small > 256) {
1500                 cifs_min_small = 256;
1501                 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1502         }
1503
1504         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1505                                                      cifs_sm_req_cachep);
1506
1507         if (cifs_sm_req_poolp == NULL) {
1508                 mempool_destroy(cifs_req_poolp);
1509                 kmem_cache_destroy(cifs_req_cachep);
1510                 kmem_cache_destroy(cifs_sm_req_cachep);
1511                 return -ENOMEM;
1512         }
1513
1514         return 0;
1515 }
1516
1517 static void
1518 cifs_destroy_request_bufs(void)
1519 {
1520         mempool_destroy(cifs_req_poolp);
1521         kmem_cache_destroy(cifs_req_cachep);
1522         mempool_destroy(cifs_sm_req_poolp);
1523         kmem_cache_destroy(cifs_sm_req_cachep);
1524 }
1525
1526 static int
1527 cifs_init_mids(void)
1528 {
1529         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1530                                             sizeof(struct mid_q_entry), 0,
1531                                             SLAB_HWCACHE_ALIGN, NULL);
1532         if (cifs_mid_cachep == NULL)
1533                 return -ENOMEM;
1534
1535         /* 3 is a reasonable minimum number of simultaneous operations */
1536         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1537         if (cifs_mid_poolp == NULL) {
1538                 kmem_cache_destroy(cifs_mid_cachep);
1539                 return -ENOMEM;
1540         }
1541
1542         return 0;
1543 }
1544
1545 static void
1546 cifs_destroy_mids(void)
1547 {
1548         mempool_destroy(cifs_mid_poolp);
1549         kmem_cache_destroy(cifs_mid_cachep);
1550 }
1551
1552 static int __init
1553 init_cifs(void)
1554 {
1555         int rc = 0;
1556         cifs_proc_init();
1557         INIT_LIST_HEAD(&cifs_tcp_ses_list);
1558 /*
1559  *  Initialize Global counters
1560  */
1561         atomic_set(&sesInfoAllocCount, 0);
1562         atomic_set(&tconInfoAllocCount, 0);
1563         atomic_set(&tcpSesNextId, 0);
1564         atomic_set(&tcpSesAllocCount, 0);
1565         atomic_set(&tcpSesReconnectCount, 0);
1566         atomic_set(&tconInfoReconnectCount, 0);
1567
1568         atomic_set(&bufAllocCount, 0);
1569         atomic_set(&smBufAllocCount, 0);
1570 #ifdef CONFIG_CIFS_STATS2
1571         atomic_set(&totBufAllocCount, 0);
1572         atomic_set(&totSmBufAllocCount, 0);
1573         if (slow_rsp_threshold < 1)
1574                 cifs_dbg(FYI, "slow_response_threshold msgs disabled\n");
1575         else if (slow_rsp_threshold > 32767)
1576                 cifs_dbg(VFS,
1577                        "slow response threshold set higher than recommended (0 to 32767)\n");
1578 #endif /* CONFIG_CIFS_STATS2 */
1579
1580         atomic_set(&midCount, 0);
1581         GlobalCurrentXid = 0;
1582         GlobalTotalActiveXid = 0;
1583         GlobalMaxActiveXid = 0;
1584         spin_lock_init(&cifs_tcp_ses_lock);
1585         spin_lock_init(&GlobalMid_Lock);
1586
1587         cifs_lock_secret = get_random_u32();
1588
1589         if (cifs_max_pending < 2) {
1590                 cifs_max_pending = 2;
1591                 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1592         } else if (cifs_max_pending > CIFS_MAX_REQ) {
1593                 cifs_max_pending = CIFS_MAX_REQ;
1594                 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1595                          CIFS_MAX_REQ);
1596         }
1597
1598         cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1599         if (!cifsiod_wq) {
1600                 rc = -ENOMEM;
1601                 goto out_clean_proc;
1602         }
1603
1604         /*
1605          * Consider in future setting limit!=0 maybe to min(num_of_cores - 1, 3)
1606          * so that we don't launch too many worker threads but
1607          * Documentation/core-api/workqueue.rst recommends setting it to 0
1608          */
1609
1610         /* WQ_UNBOUND allows decrypt tasks to run on any CPU */
1611         decrypt_wq = alloc_workqueue("smb3decryptd",
1612                                      WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1613         if (!decrypt_wq) {
1614                 rc = -ENOMEM;
1615                 goto out_destroy_cifsiod_wq;
1616         }
1617
1618         fileinfo_put_wq = alloc_workqueue("cifsfileinfoput",
1619                                      WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1620         if (!fileinfo_put_wq) {
1621                 rc = -ENOMEM;
1622                 goto out_destroy_decrypt_wq;
1623         }
1624
1625         cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1626                                          WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1627         if (!cifsoplockd_wq) {
1628                 rc = -ENOMEM;
1629                 goto out_destroy_fileinfo_put_wq;
1630         }
1631
1632         deferredclose_wq = alloc_workqueue("deferredclose",
1633                                            WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1634         if (!deferredclose_wq) {
1635                 rc = -ENOMEM;
1636                 goto out_destroy_cifsoplockd_wq;
1637         }
1638
1639         rc = cifs_init_inodecache();
1640         if (rc)
1641                 goto out_destroy_deferredclose_wq;
1642
1643         rc = cifs_init_mids();
1644         if (rc)
1645                 goto out_destroy_inodecache;
1646
1647         rc = cifs_init_request_bufs();
1648         if (rc)
1649                 goto out_destroy_mids;
1650
1651 #ifdef CONFIG_CIFS_DFS_UPCALL
1652         rc = dfs_cache_init();
1653         if (rc)
1654                 goto out_destroy_request_bufs;
1655 #endif /* CONFIG_CIFS_DFS_UPCALL */
1656 #ifdef CONFIG_CIFS_UPCALL
1657         rc = init_cifs_spnego();
1658         if (rc)
1659                 goto out_destroy_dfs_cache;
1660 #endif /* CONFIG_CIFS_UPCALL */
1661 #ifdef CONFIG_CIFS_SWN_UPCALL
1662         rc = cifs_genl_init();
1663         if (rc)
1664                 goto out_register_key_type;
1665 #endif /* CONFIG_CIFS_SWN_UPCALL */
1666
1667         rc = init_cifs_idmap();
1668         if (rc)
1669                 goto out_cifs_swn_init;
1670
1671         rc = register_filesystem(&cifs_fs_type);
1672         if (rc)
1673                 goto out_init_cifs_idmap;
1674
1675         rc = register_filesystem(&smb3_fs_type);
1676         if (rc) {
1677                 unregister_filesystem(&cifs_fs_type);
1678                 goto out_init_cifs_idmap;
1679         }
1680
1681         return 0;
1682
1683 out_init_cifs_idmap:
1684         exit_cifs_idmap();
1685 out_cifs_swn_init:
1686 #ifdef CONFIG_CIFS_SWN_UPCALL
1687         cifs_genl_exit();
1688 out_register_key_type:
1689 #endif
1690 #ifdef CONFIG_CIFS_UPCALL
1691         exit_cifs_spnego();
1692 out_destroy_dfs_cache:
1693 #endif
1694 #ifdef CONFIG_CIFS_DFS_UPCALL
1695         dfs_cache_destroy();
1696 out_destroy_request_bufs:
1697 #endif
1698         cifs_destroy_request_bufs();
1699 out_destroy_mids:
1700         cifs_destroy_mids();
1701 out_destroy_inodecache:
1702         cifs_destroy_inodecache();
1703 out_destroy_deferredclose_wq:
1704         destroy_workqueue(deferredclose_wq);
1705 out_destroy_cifsoplockd_wq:
1706         destroy_workqueue(cifsoplockd_wq);
1707 out_destroy_fileinfo_put_wq:
1708         destroy_workqueue(fileinfo_put_wq);
1709 out_destroy_decrypt_wq:
1710         destroy_workqueue(decrypt_wq);
1711 out_destroy_cifsiod_wq:
1712         destroy_workqueue(cifsiod_wq);
1713 out_clean_proc:
1714         cifs_proc_clean();
1715         return rc;
1716 }
1717
1718 static void __exit
1719 exit_cifs(void)
1720 {
1721         cifs_dbg(NOISY, "exit_smb3\n");
1722         unregister_filesystem(&cifs_fs_type);
1723         unregister_filesystem(&smb3_fs_type);
1724         cifs_dfs_release_automount_timer();
1725         exit_cifs_idmap();
1726 #ifdef CONFIG_CIFS_SWN_UPCALL
1727         cifs_genl_exit();
1728 #endif
1729 #ifdef CONFIG_CIFS_UPCALL
1730         exit_cifs_spnego();
1731 #endif
1732 #ifdef CONFIG_CIFS_DFS_UPCALL
1733         dfs_cache_destroy();
1734 #endif
1735         cifs_destroy_request_bufs();
1736         cifs_destroy_mids();
1737         cifs_destroy_inodecache();
1738         destroy_workqueue(deferredclose_wq);
1739         destroy_workqueue(cifsoplockd_wq);
1740         destroy_workqueue(decrypt_wq);
1741         destroy_workqueue(fileinfo_put_wq);
1742         destroy_workqueue(cifsiod_wq);
1743         cifs_proc_clean();
1744 }
1745
1746 MODULE_AUTHOR("Steve French");
1747 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1748 MODULE_DESCRIPTION
1749         ("VFS to access SMB3 servers e.g. Samba, Macs, Azure and Windows (and "
1750         "also older servers complying with the SNIA CIFS Specification)");
1751 MODULE_VERSION(CIFS_VERSION);
1752 MODULE_SOFTDEP("ecb");
1753 MODULE_SOFTDEP("hmac");
1754 MODULE_SOFTDEP("md5");
1755 MODULE_SOFTDEP("nls");
1756 MODULE_SOFTDEP("aes");
1757 MODULE_SOFTDEP("cmac");
1758 MODULE_SOFTDEP("sha256");
1759 MODULE_SOFTDEP("sha512");
1760 MODULE_SOFTDEP("aead2");
1761 MODULE_SOFTDEP("ccm");
1762 MODULE_SOFTDEP("gcm");
1763 module_init(init_cifs)
1764 module_exit(exit_cifs)