fs/cifs/cifsfs.c

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