fs/cifs/cifsfs.c

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