~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/cifs/cifsfs.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp