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