1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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 <net/ipv6.h>
41#include "cifsfs.h"
42#include "cifspdu.h"
43#define DECLARE_GLOBALS_HERE
44#include "cifsglob.h"
45#include "cifsproto.h"
46#include "cifs_debug.h"
47#include "cifs_fs_sb.h"
48#include <linux/mm.h>
49#include <linux/key-type.h>
50#include "cifs_spnego.h"
51#include "fscache.h"
52#ifdef CONFIG_CIFS_SMB2
53#include "smb2pdu.h"
54#endif
55
56int cifsFYI = 0;
57bool traceSMB;
58bool enable_oplocks = true;
59bool linuxExtEnabled = true;
60bool lookupCacheEnabled = true;
61unsigned int global_secflags = CIFSSEC_DEF;
62
63unsigned int sign_CIFS_PDUs = 1;
64static const struct super_operations cifs_super_ops;
65unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
66module_param(CIFSMaxBufSize, uint, 0);
67MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
68 "Default: 16384 Range: 8192 to 130048");
69unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
70module_param(cifs_min_rcv, uint, 0);
71MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
72 "1 to 64");
73unsigned int cifs_min_small = 30;
74module_param(cifs_min_small, uint, 0);
75MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
76 "Range: 2 to 256");
77unsigned int cifs_max_pending = CIFS_MAX_REQ;
78module_param(cifs_max_pending, uint, 0444);
79MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
80 "Default: 32767 Range: 2 to 32767.");
81module_param(enable_oplocks, bool, 0644);
82MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
83
84extern mempool_t *cifs_sm_req_poolp;
85extern mempool_t *cifs_req_poolp;
86extern mempool_t *cifs_mid_poolp;
87
88struct workqueue_struct *cifsiod_wq;
89
90
91
92
93
94
95
96void
97cifs_sb_active(struct super_block *sb)
98{
99 struct cifs_sb_info *server = CIFS_SB(sb);
100
101 if (atomic_inc_return(&server->active) == 1)
102 atomic_inc(&sb->s_active);
103}
104
105void
106cifs_sb_deactive(struct super_block *sb)
107{
108 struct cifs_sb_info *server = CIFS_SB(sb);
109
110 if (atomic_dec_and_test(&server->active))
111 deactivate_super(sb);
112}
113
114static int
115cifs_read_super(struct super_block *sb)
116{
117 struct inode *inode;
118 struct cifs_sb_info *cifs_sb;
119 struct cifs_tcon *tcon;
120 int rc = 0;
121
122 cifs_sb = CIFS_SB(sb);
123 tcon = cifs_sb_master_tcon(cifs_sb);
124
125 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
126 sb->s_flags |= MS_POSIXACL;
127
128 if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
129 sb->s_maxbytes = MAX_LFS_FILESIZE;
130 else
131 sb->s_maxbytes = MAX_NON_LFS;
132
133
134 sb->s_time_gran = 100;
135
136 sb->s_magic = CIFS_MAGIC_NUMBER;
137 sb->s_op = &cifs_super_ops;
138 sb->s_bdi = &cifs_sb->bdi;
139 sb->s_blocksize = CIFS_MAX_MSGSIZE;
140 sb->s_blocksize_bits = 14;
141 inode = cifs_root_iget(sb);
142
143 if (IS_ERR(inode)) {
144 rc = PTR_ERR(inode);
145 goto out_no_root;
146 }
147
148 if (tcon->nocase)
149 sb->s_d_op = &cifs_ci_dentry_ops;
150 else
151 sb->s_d_op = &cifs_dentry_ops;
152
153 sb->s_root = d_make_root(inode);
154 if (!sb->s_root) {
155 rc = -ENOMEM;
156 goto out_no_root;
157 }
158
159#ifdef CONFIG_CIFS_NFSD_EXPORT
160 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
161 cifs_dbg(FYI, "export ops supported\n");
162 sb->s_export_op = &cifs_export_ops;
163 }
164#endif
165
166 return 0;
167
168out_no_root:
169 cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
170 return rc;
171}
172
173static void cifs_kill_sb(struct super_block *sb)
174{
175 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
176 kill_anon_super(sb);
177 cifs_umount(cifs_sb);
178}
179
180static int
181cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
182{
183 struct super_block *sb = dentry->d_sb;
184 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
185 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
186 struct TCP_Server_Info *server = tcon->ses->server;
187 unsigned int xid;
188 int rc = 0;
189
190 xid = get_xid();
191
192
193
194
195
196
197
198
199 buf->f_namelen = PATH_MAX;
200 buf->f_files = 0;
201 buf->f_ffree = 0;
202
203 if (server->ops->queryfs)
204 rc = server->ops->queryfs(xid, tcon, buf);
205
206 free_xid(xid);
207 return 0;
208}
209
210static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
211{
212 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
213 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
214 struct TCP_Server_Info *server = tcon->ses->server;
215
216 if (server->ops->fallocate)
217 return server->ops->fallocate(file, tcon, mode, off, len);
218
219 return -EOPNOTSUPP;
220}
221
222static int cifs_permission(struct inode *inode, int mask)
223{
224 struct cifs_sb_info *cifs_sb;
225
226 cifs_sb = CIFS_SB(inode->i_sb);
227
228 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
229 if ((mask & MAY_EXEC) && !execute_ok(inode))
230 return -EACCES;
231 else
232 return 0;
233 } else
234
235
236
237 return generic_permission(inode, mask);
238}
239
240static struct kmem_cache *cifs_inode_cachep;
241static struct kmem_cache *cifs_req_cachep;
242static struct kmem_cache *cifs_mid_cachep;
243static struct kmem_cache *cifs_sm_req_cachep;
244mempool_t *cifs_sm_req_poolp;
245mempool_t *cifs_req_poolp;
246mempool_t *cifs_mid_poolp;
247
248static struct inode *
249cifs_alloc_inode(struct super_block *sb)
250{
251 struct cifsInodeInfo *cifs_inode;
252 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
253 if (!cifs_inode)
254 return NULL;
255 cifs_inode->cifsAttrs = 0x20;
256 cifs_inode->time = 0;
257
258
259
260
261 cifs_set_oplock_level(cifs_inode, 0);
262 cifs_inode->flags = 0;
263 spin_lock_init(&cifs_inode->writers_lock);
264 cifs_inode->writers = 0;
265 cifs_inode->vfs_inode.i_blkbits = 14;
266 cifs_inode->server_eof = 0;
267 cifs_inode->uniqueid = 0;
268 cifs_inode->createtime = 0;
269 cifs_inode->epoch = 0;
270#ifdef CONFIG_CIFS_SMB2
271 get_random_bytes(cifs_inode->lease_key, SMB2_LEASE_KEY_SIZE);
272#endif
273
274
275
276
277
278 INIT_LIST_HEAD(&cifs_inode->openFileList);
279 INIT_LIST_HEAD(&cifs_inode->llist);
280 return &cifs_inode->vfs_inode;
281}
282
283static void cifs_i_callback(struct rcu_head *head)
284{
285 struct inode *inode = container_of(head, struct inode, i_rcu);
286 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
287}
288
289static void
290cifs_destroy_inode(struct inode *inode)
291{
292 call_rcu(&inode->i_rcu, cifs_i_callback);
293}
294
295static void
296cifs_evict_inode(struct inode *inode)
297{
298 truncate_inode_pages_final(&inode->i_data);
299 clear_inode(inode);
300 cifs_fscache_release_inode_cookie(inode);
301}
302
303static void
304cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
305{
306 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
307 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
308
309 seq_puts(s, ",addr=");
310
311 switch (server->dstaddr.ss_family) {
312 case AF_INET:
313 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
314 break;
315 case AF_INET6:
316 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
317 if (sa6->sin6_scope_id)
318 seq_printf(s, "%%%u", sa6->sin6_scope_id);
319 break;
320 default:
321 seq_puts(s, "(unknown)");
322 }
323}
324
325static void
326cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
327{
328 if (ses->sectype == Unspecified) {
329 if (ses->user_name == NULL)
330 seq_puts(s, ",sec=none");
331 return;
332 }
333
334 seq_puts(s, ",sec=");
335
336 switch (ses->sectype) {
337 case LANMAN:
338 seq_puts(s, "lanman");
339 break;
340 case NTLMv2:
341 seq_puts(s, "ntlmv2");
342 break;
343 case NTLM:
344 seq_puts(s, "ntlm");
345 break;
346 case Kerberos:
347 seq_puts(s, "krb5");
348 break;
349 case RawNTLMSSP:
350 seq_puts(s, "ntlmssp");
351 break;
352 default:
353
354 seq_puts(s, "unknown");
355 break;
356 }
357
358 if (ses->sign)
359 seq_puts(s, "i");
360}
361
362static void
363cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
364{
365 seq_puts(s, ",cache=");
366
367 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
368 seq_puts(s, "strict");
369 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
370 seq_puts(s, "none");
371 else
372 seq_puts(s, "loose");
373}
374
375static void
376cifs_show_nls(struct seq_file *s, struct nls_table *cur)
377{
378 struct nls_table *def;
379
380
381 def = load_nls_default();
382 if (def != cur)
383 seq_printf(s, ",iocharset=%s", cur->charset);
384 unload_nls(def);
385}
386
387
388
389
390
391
392static int
393cifs_show_options(struct seq_file *s, struct dentry *root)
394{
395 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
396 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
397 struct sockaddr *srcaddr;
398 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
399
400 seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
401 cifs_show_security(s, tcon->ses);
402 cifs_show_cache_flavor(s, cifs_sb);
403
404 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
405 seq_puts(s, ",multiuser");
406 else if (tcon->ses->user_name)
407 seq_show_option(s, "username", tcon->ses->user_name);
408
409 if (tcon->ses->domainName)
410 seq_show_option(s, "domain", tcon->ses->domainName);
411
412 if (srcaddr->sa_family != AF_UNSPEC) {
413 struct sockaddr_in *saddr4;
414 struct sockaddr_in6 *saddr6;
415 saddr4 = (struct sockaddr_in *)srcaddr;
416 saddr6 = (struct sockaddr_in6 *)srcaddr;
417 if (srcaddr->sa_family == AF_INET6)
418 seq_printf(s, ",srcaddr=%pI6c",
419 &saddr6->sin6_addr);
420 else if (srcaddr->sa_family == AF_INET)
421 seq_printf(s, ",srcaddr=%pI4",
422 &saddr4->sin_addr.s_addr);
423 else
424 seq_printf(s, ",srcaddr=BAD-AF:%i",
425 (int)(srcaddr->sa_family));
426 }
427
428 seq_printf(s, ",uid=%u",
429 from_kuid_munged(&init_user_ns, cifs_sb->mnt_uid));
430 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
431 seq_puts(s, ",forceuid");
432 else
433 seq_puts(s, ",noforceuid");
434
435 seq_printf(s, ",gid=%u",
436 from_kgid_munged(&init_user_ns, cifs_sb->mnt_gid));
437 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
438 seq_puts(s, ",forcegid");
439 else
440 seq_puts(s, ",noforcegid");
441
442 cifs_show_address(s, tcon->ses->server);
443
444 if (!tcon->unix_ext)
445 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
446 cifs_sb->mnt_file_mode,
447 cifs_sb->mnt_dir_mode);
448
449 cifs_show_nls(s, cifs_sb->local_nls);
450
451 if (tcon->seal)
452 seq_puts(s, ",seal");
453 if (tcon->nocase)
454 seq_puts(s, ",nocase");
455 if (tcon->retry)
456 seq_puts(s, ",hard");
457 if (tcon->use_persistent)
458 seq_puts(s, ",persistenthandles");
459 else if (tcon->use_resilient)
460 seq_puts(s, ",resilienthandles");
461 if (tcon->unix_ext)
462 seq_puts(s, ",unix");
463 else
464 seq_puts(s, ",nounix");
465 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
466 seq_puts(s, ",posixpaths");
467 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
468 seq_puts(s, ",setuids");
469 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
470 seq_puts(s, ",serverino");
471 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
472 seq_puts(s, ",rwpidforward");
473 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
474 seq_puts(s, ",forcemand");
475 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
476 seq_puts(s, ",nouser_xattr");
477 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
478 seq_puts(s, ",mapchars");
479 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
480 seq_puts(s, ",mapposix");
481 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
482 seq_puts(s, ",sfu");
483 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
484 seq_puts(s, ",nobrl");
485 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
486 seq_puts(s, ",cifsacl");
487 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
488 seq_puts(s, ",dynperm");
489 if (root->d_sb->s_flags & MS_POSIXACL)
490 seq_puts(s, ",acl");
491 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
492 seq_puts(s, ",mfsymlinks");
493 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
494 seq_puts(s, ",fsc");
495 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
496 seq_puts(s, ",nostrictsync");
497 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
498 seq_puts(s, ",noperm");
499 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
500 seq_printf(s, ",backupuid=%u",
501 from_kuid_munged(&init_user_ns,
502 cifs_sb->mnt_backupuid));
503 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
504 seq_printf(s, ",backupgid=%u",
505 from_kgid_munged(&init_user_ns,
506 cifs_sb->mnt_backupgid));
507
508 seq_printf(s, ",rsize=%u", cifs_sb->rsize);
509 seq_printf(s, ",wsize=%u", cifs_sb->wsize);
510 seq_printf(s, ",echo_interval=%lu",
511 tcon->ses->server->echo_interval / HZ);
512
513 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
514
515 return 0;
516}
517
518static void cifs_umount_begin(struct super_block *sb)
519{
520 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
521 struct cifs_tcon *tcon;
522
523 if (cifs_sb == NULL)
524 return;
525
526 tcon = cifs_sb_master_tcon(cifs_sb);
527
528 spin_lock(&cifs_tcp_ses_lock);
529 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
530
531
532
533 spin_unlock(&cifs_tcp_ses_lock);
534 return;
535 } else if (tcon->tc_count == 1)
536 tcon->tidStatus = CifsExiting;
537 spin_unlock(&cifs_tcp_ses_lock);
538
539
540
541 if (tcon->ses && tcon->ses->server) {
542 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
543 wake_up_all(&tcon->ses->server->request_q);
544 wake_up_all(&tcon->ses->server->response_q);
545 msleep(1);
546
547 wake_up_all(&tcon->ses->server->response_q);
548 msleep(1);
549 }
550
551 return;
552}
553
554#ifdef CONFIG_CIFS_STATS2
555static int cifs_show_stats(struct seq_file *s, struct dentry *root)
556{
557
558 return 0;
559}
560#endif
561
562static int cifs_remount(struct super_block *sb, int *flags, char *data)
563{
564 sync_filesystem(sb);
565 *flags |= MS_NODIRATIME;
566 return 0;
567}
568
569static int cifs_drop_inode(struct inode *inode)
570{
571 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
572
573
574 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
575 generic_drop_inode(inode);
576}
577
578static const struct super_operations cifs_super_ops = {
579 .statfs = cifs_statfs,
580 .alloc_inode = cifs_alloc_inode,
581 .destroy_inode = cifs_destroy_inode,
582 .drop_inode = cifs_drop_inode,
583 .evict_inode = cifs_evict_inode,
584
585
586
587
588 .show_options = cifs_show_options,
589 .umount_begin = cifs_umount_begin,
590 .remount_fs = cifs_remount,
591#ifdef CONFIG_CIFS_STATS2
592 .show_stats = cifs_show_stats,
593#endif
594};
595
596
597
598
599
600static struct dentry *
601cifs_get_root(struct smb_vol *vol, struct super_block *sb)
602{
603 struct dentry *dentry;
604 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
605 char *full_path = NULL;
606 char *s, *p;
607 char sep;
608
609 full_path = cifs_build_path_to_root(vol, cifs_sb,
610 cifs_sb_master_tcon(cifs_sb));
611 if (full_path == NULL)
612 return ERR_PTR(-ENOMEM);
613
614 cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
615
616 sep = CIFS_DIR_SEP(cifs_sb);
617 dentry = dget(sb->s_root);
618 p = s = full_path;
619
620 do {
621 struct inode *dir = d_inode(dentry);
622 struct dentry *child;
623
624 if (!dir) {
625 dput(dentry);
626 dentry = ERR_PTR(-ENOENT);
627 break;
628 }
629 if (!S_ISDIR(dir->i_mode)) {
630 dput(dentry);
631 dentry = ERR_PTR(-ENOTDIR);
632 break;
633 }
634
635
636 while (*s == sep)
637 s++;
638 if (!*s)
639 break;
640 p = s++;
641
642 while (*s && *s != sep)
643 s++;
644
645 child = lookup_one_len_unlocked(p, dentry, s - p);
646 dput(dentry);
647 dentry = child;
648 } while (!IS_ERR(dentry));
649 kfree(full_path);
650 return dentry;
651}
652
653static int cifs_set_super(struct super_block *sb, void *data)
654{
655 struct cifs_mnt_data *mnt_data = data;
656 sb->s_fs_info = mnt_data->cifs_sb;
657 return set_anon_super(sb, NULL);
658}
659
660static struct dentry *
661cifs_do_mount(struct file_system_type *fs_type,
662 int flags, const char *dev_name, void *data)
663{
664 int rc;
665 struct super_block *sb;
666 struct cifs_sb_info *cifs_sb;
667 struct smb_vol *volume_info;
668 struct cifs_mnt_data mnt_data;
669 struct dentry *root;
670
671 cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
672
673 volume_info = cifs_get_volume_info((char *)data, dev_name);
674 if (IS_ERR(volume_info))
675 return ERR_CAST(volume_info);
676
677 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
678 if (cifs_sb == NULL) {
679 root = ERR_PTR(-ENOMEM);
680 goto out_nls;
681 }
682
683 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
684 if (cifs_sb->mountdata == NULL) {
685 root = ERR_PTR(-ENOMEM);
686 goto out_cifs_sb;
687 }
688
689 cifs_setup_cifs_sb(volume_info, cifs_sb);
690
691 rc = cifs_mount(cifs_sb, volume_info);
692 if (rc) {
693 if (!(flags & MS_SILENT))
694 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
695 rc);
696 root = ERR_PTR(rc);
697 goto out_mountdata;
698 }
699
700 mnt_data.vol = volume_info;
701 mnt_data.cifs_sb = cifs_sb;
702 mnt_data.flags = flags;
703
704
705 flags |= MS_NODIRATIME | MS_NOATIME;
706
707 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
708 if (IS_ERR(sb)) {
709 root = ERR_CAST(sb);
710 cifs_umount(cifs_sb);
711 goto out;
712 }
713
714 if (sb->s_root) {
715 cifs_dbg(FYI, "Use existing superblock\n");
716 cifs_umount(cifs_sb);
717 } else {
718 rc = cifs_read_super(sb);
719 if (rc) {
720 root = ERR_PTR(rc);
721 goto out_super;
722 }
723
724 sb->s_flags |= MS_ACTIVE;
725 }
726
727 root = cifs_get_root(volume_info, sb);
728 if (IS_ERR(root))
729 goto out_super;
730
731 cifs_dbg(FYI, "dentry root is: %p\n", root);
732 goto out;
733
734out_super:
735 deactivate_locked_super(sb);
736out:
737 cifs_cleanup_volume_info(volume_info);
738 return root;
739
740out_mountdata:
741 kfree(cifs_sb->mountdata);
742out_cifs_sb:
743 kfree(cifs_sb);
744out_nls:
745 unload_nls(volume_info->local_nls);
746 goto out;
747}
748
749static ssize_t
750cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
751{
752 ssize_t rc;
753 struct inode *inode = file_inode(iocb->ki_filp);
754
755 if (iocb->ki_filp->f_flags & O_DIRECT)
756 return cifs_user_readv(iocb, iter);
757
758 rc = cifs_revalidate_mapping(inode);
759 if (rc)
760 return rc;
761
762 return generic_file_read_iter(iocb, iter);
763}
764
765static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
766{
767 struct inode *inode = file_inode(iocb->ki_filp);
768 struct cifsInodeInfo *cinode = CIFS_I(inode);
769 ssize_t written;
770 int rc;
771
772 if (iocb->ki_filp->f_flags & O_DIRECT) {
773 written = cifs_user_writev(iocb, from);
774 if (written > 0 && CIFS_CACHE_READ(cinode)) {
775 cifs_zap_mapping(inode);
776 cifs_dbg(FYI,
777 "Set no oplock for inode=%p after a write operation\n",
778 inode);
779 cinode->oplock = 0;
780 }
781 return written;
782 }
783
784 written = cifs_get_writer(cinode);
785 if (written)
786 return written;
787
788 written = generic_file_write_iter(iocb, from);
789
790 if (CIFS_CACHE_WRITE(CIFS_I(inode)))
791 goto out;
792
793 rc = filemap_fdatawrite(inode->i_mapping);
794 if (rc)
795 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
796 rc, inode);
797
798out:
799 cifs_put_writer(cinode);
800 return written;
801}
802
803static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
804{
805
806
807
808
809 if (whence != SEEK_SET && whence != SEEK_CUR) {
810 int rc;
811 struct inode *inode = file_inode(file);
812
813
814
815
816
817 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
818 inode->i_mapping->nrpages != 0) {
819 rc = filemap_fdatawait(inode->i_mapping);
820 if (rc) {
821 mapping_set_error(inode->i_mapping, rc);
822 return rc;
823 }
824 }
825
826
827
828
829
830 CIFS_I(inode)->time = 0;
831
832 rc = cifs_revalidate_file_attr(file);
833 if (rc < 0)
834 return (loff_t)rc;
835 }
836 return generic_file_llseek(file, offset, whence);
837}
838
839static int
840cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
841{
842
843
844
845
846 struct inode *inode = file_inode(file);
847 struct cifsFileInfo *cfile = file->private_data;
848
849 if (!(S_ISREG(inode->i_mode)))
850 return -EINVAL;
851
852
853 if (arg == F_UNLCK ||
854 ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
855 ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
856 return generic_setlease(file, arg, lease, priv);
857 else if (tlink_tcon(cfile->tlink)->local_lease &&
858 !CIFS_CACHE_READ(CIFS_I(inode)))
859
860
861
862
863
864
865
866
867 return generic_setlease(file, arg, lease, priv);
868 else
869 return -EAGAIN;
870}
871
872struct file_system_type cifs_fs_type = {
873 .owner = THIS_MODULE,
874 .name = "cifs",
875 .mount = cifs_do_mount,
876 .kill_sb = cifs_kill_sb,
877
878};
879MODULE_ALIAS_FS("cifs");
880const struct inode_operations cifs_dir_inode_ops = {
881 .create = cifs_create,
882 .atomic_open = cifs_atomic_open,
883 .lookup = cifs_lookup,
884 .getattr = cifs_getattr,
885 .unlink = cifs_unlink,
886 .link = cifs_hardlink,
887 .mkdir = cifs_mkdir,
888 .rmdir = cifs_rmdir,
889 .rename2 = cifs_rename2,
890 .permission = cifs_permission,
891
892 .setattr = cifs_setattr,
893 .symlink = cifs_symlink,
894 .mknod = cifs_mknod,
895#ifdef CONFIG_CIFS_XATTR
896 .setxattr = cifs_setxattr,
897 .getxattr = cifs_getxattr,
898 .listxattr = cifs_listxattr,
899 .removexattr = cifs_removexattr,
900#endif
901};
902
903const struct inode_operations cifs_file_inode_ops = {
904
905 .setattr = cifs_setattr,
906 .getattr = cifs_getattr,
907 .permission = cifs_permission,
908#ifdef CONFIG_CIFS_XATTR
909 .setxattr = cifs_setxattr,
910 .getxattr = cifs_getxattr,
911 .listxattr = cifs_listxattr,
912 .removexattr = cifs_removexattr,
913#endif
914};
915
916const struct inode_operations cifs_symlink_inode_ops = {
917 .readlink = generic_readlink,
918 .get_link = cifs_get_link,
919 .permission = cifs_permission,
920
921
922
923#ifdef CONFIG_CIFS_XATTR
924 .setxattr = cifs_setxattr,
925 .getxattr = cifs_getxattr,
926 .listxattr = cifs_listxattr,
927 .removexattr = cifs_removexattr,
928#endif
929};
930
931static int cifs_clone_file_range(struct file *src_file, loff_t off,
932 struct file *dst_file, loff_t destoff, u64 len)
933{
934 struct inode *src_inode = file_inode(src_file);
935 struct inode *target_inode = file_inode(dst_file);
936 struct cifsFileInfo *smb_file_src = src_file->private_data;
937 struct cifsFileInfo *smb_file_target = dst_file->private_data;
938 struct cifs_tcon *target_tcon = tlink_tcon(smb_file_target->tlink);
939 unsigned int xid;
940 int rc;
941
942 cifs_dbg(FYI, "clone range\n");
943
944 xid = get_xid();
945
946 if (!src_file->private_data || !dst_file->private_data) {
947 rc = -EBADF;
948 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
949 goto out;
950 }
951
952
953
954
955
956
957 lock_two_nondirectories(target_inode, src_inode);
958
959 if (len == 0)
960 len = src_inode->i_size - off;
961
962 cifs_dbg(FYI, "about to flush pages\n");
963
964 truncate_inode_pages_range(&target_inode->i_data, destoff,
965 PAGE_ALIGN(destoff + len)-1);
966
967 if (target_tcon->ses->server->ops->duplicate_extents)
968 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
969 smb_file_src, smb_file_target, off, len, destoff);
970 else
971 rc = -EOPNOTSUPP;
972
973
974
975 CIFS_I(target_inode)->time = 0;
976
977
978 unlock_two_nondirectories(src_inode, target_inode);
979out:
980 free_xid(xid);
981 return rc;
982}
983
984const struct file_operations cifs_file_ops = {
985 .read_iter = cifs_loose_read_iter,
986 .write_iter = cifs_file_write_iter,
987 .open = cifs_open,
988 .release = cifs_close,
989 .lock = cifs_lock,
990 .fsync = cifs_fsync,
991 .flush = cifs_flush,
992 .mmap = cifs_file_mmap,
993 .splice_read = generic_file_splice_read,
994 .llseek = cifs_llseek,
995 .unlocked_ioctl = cifs_ioctl,
996 .clone_file_range = cifs_clone_file_range,
997 .setlease = cifs_setlease,
998 .fallocate = cifs_fallocate,
999};
1000
1001const struct file_operations cifs_file_strict_ops = {
1002 .read_iter = cifs_strict_readv,
1003 .write_iter = cifs_strict_writev,
1004 .open = cifs_open,
1005 .release = cifs_close,
1006 .lock = cifs_lock,
1007 .fsync = cifs_strict_fsync,
1008 .flush = cifs_flush,
1009 .mmap = cifs_file_strict_mmap,
1010 .splice_read = generic_file_splice_read,
1011 .llseek = cifs_llseek,
1012 .unlocked_ioctl = cifs_ioctl,
1013 .clone_file_range = cifs_clone_file_range,
1014 .setlease = cifs_setlease,
1015 .fallocate = cifs_fallocate,
1016};
1017
1018const struct file_operations cifs_file_direct_ops = {
1019
1020 .read_iter = cifs_user_readv,
1021 .write_iter = cifs_user_writev,
1022 .open = cifs_open,
1023 .release = cifs_close,
1024 .lock = cifs_lock,
1025 .fsync = cifs_fsync,
1026 .flush = cifs_flush,
1027 .mmap = cifs_file_mmap,
1028 .splice_read = generic_file_splice_read,
1029 .unlocked_ioctl = cifs_ioctl,
1030 .clone_file_range = cifs_clone_file_range,
1031 .llseek = cifs_llseek,
1032 .setlease = cifs_setlease,
1033 .fallocate = cifs_fallocate,
1034};
1035
1036const struct file_operations cifs_file_nobrl_ops = {
1037 .read_iter = cifs_loose_read_iter,
1038 .write_iter = cifs_file_write_iter,
1039 .open = cifs_open,
1040 .release = cifs_close,
1041 .fsync = cifs_fsync,
1042 .flush = cifs_flush,
1043 .mmap = cifs_file_mmap,
1044 .splice_read = generic_file_splice_read,
1045 .llseek = cifs_llseek,
1046 .unlocked_ioctl = cifs_ioctl,
1047 .clone_file_range = cifs_clone_file_range,
1048 .setlease = cifs_setlease,
1049 .fallocate = cifs_fallocate,
1050};
1051
1052const struct file_operations cifs_file_strict_nobrl_ops = {
1053 .read_iter = cifs_strict_readv,
1054 .write_iter = cifs_strict_writev,
1055 .open = cifs_open,
1056 .release = cifs_close,
1057 .fsync = cifs_strict_fsync,
1058 .flush = cifs_flush,
1059 .mmap = cifs_file_strict_mmap,
1060 .splice_read = generic_file_splice_read,
1061 .llseek = cifs_llseek,
1062 .unlocked_ioctl = cifs_ioctl,
1063 .clone_file_range = cifs_clone_file_range,
1064 .setlease = cifs_setlease,
1065 .fallocate = cifs_fallocate,
1066};
1067
1068const struct file_operations cifs_file_direct_nobrl_ops = {
1069
1070 .read_iter = cifs_user_readv,
1071 .write_iter = cifs_user_writev,
1072 .open = cifs_open,
1073 .release = cifs_close,
1074 .fsync = cifs_fsync,
1075 .flush = cifs_flush,
1076 .mmap = cifs_file_mmap,
1077 .splice_read = generic_file_splice_read,
1078 .unlocked_ioctl = cifs_ioctl,
1079 .clone_file_range = cifs_clone_file_range,
1080 .llseek = cifs_llseek,
1081 .setlease = cifs_setlease,
1082 .fallocate = cifs_fallocate,
1083};
1084
1085const struct file_operations cifs_dir_ops = {
1086 .iterate = cifs_readdir,
1087 .release = cifs_closedir,
1088 .read = generic_read_dir,
1089 .unlocked_ioctl = cifs_ioctl,
1090 .clone_file_range = cifs_clone_file_range,
1091 .llseek = generic_file_llseek,
1092};
1093
1094static void
1095cifs_init_once(void *inode)
1096{
1097 struct cifsInodeInfo *cifsi = inode;
1098
1099 inode_init_once(&cifsi->vfs_inode);
1100 init_rwsem(&cifsi->lock_sem);
1101}
1102
1103static int __init
1104cifs_init_inodecache(void)
1105{
1106 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1107 sizeof(struct cifsInodeInfo),
1108 0, (SLAB_RECLAIM_ACCOUNT|
1109 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1110 cifs_init_once);
1111 if (cifs_inode_cachep == NULL)
1112 return -ENOMEM;
1113
1114 return 0;
1115}
1116
1117static void
1118cifs_destroy_inodecache(void)
1119{
1120
1121
1122
1123
1124 rcu_barrier();
1125 kmem_cache_destroy(cifs_inode_cachep);
1126}
1127
1128static int
1129cifs_init_request_bufs(void)
1130{
1131 size_t max_hdr_size = MAX_CIFS_HDR_SIZE;
1132#ifdef CONFIG_CIFS_SMB2
1133
1134
1135
1136
1137 max_hdr_size = MAX_SMB2_HDR_SIZE;
1138#endif
1139 if (CIFSMaxBufSize < 8192) {
1140
1141
1142 CIFSMaxBufSize = 8192;
1143 } else if (CIFSMaxBufSize > 1024*127) {
1144 CIFSMaxBufSize = 1024 * 127;
1145 } else {
1146 CIFSMaxBufSize &= 0x1FE00;
1147 }
1148
1149
1150
1151
1152 cifs_req_cachep = kmem_cache_create("cifs_request",
1153 CIFSMaxBufSize + max_hdr_size, 0,
1154 SLAB_HWCACHE_ALIGN, NULL);
1155 if (cifs_req_cachep == NULL)
1156 return -ENOMEM;
1157
1158 if (cifs_min_rcv < 1)
1159 cifs_min_rcv = 1;
1160 else if (cifs_min_rcv > 64) {
1161 cifs_min_rcv = 64;
1162 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1163 }
1164
1165 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1166 cifs_req_cachep);
1167
1168 if (cifs_req_poolp == NULL) {
1169 kmem_cache_destroy(cifs_req_cachep);
1170 return -ENOMEM;
1171 }
1172
1173
1174
1175
1176
1177
1178
1179
1180 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
1181 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1182 NULL);
1183 if (cifs_sm_req_cachep == NULL) {
1184 mempool_destroy(cifs_req_poolp);
1185 kmem_cache_destroy(cifs_req_cachep);
1186 return -ENOMEM;
1187 }
1188
1189 if (cifs_min_small < 2)
1190 cifs_min_small = 2;
1191 else if (cifs_min_small > 256) {
1192 cifs_min_small = 256;
1193 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1194 }
1195
1196 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1197 cifs_sm_req_cachep);
1198
1199 if (cifs_sm_req_poolp == NULL) {
1200 mempool_destroy(cifs_req_poolp);
1201 kmem_cache_destroy(cifs_req_cachep);
1202 kmem_cache_destroy(cifs_sm_req_cachep);
1203 return -ENOMEM;
1204 }
1205
1206 return 0;
1207}
1208
1209static void
1210cifs_destroy_request_bufs(void)
1211{
1212 mempool_destroy(cifs_req_poolp);
1213 kmem_cache_destroy(cifs_req_cachep);
1214 mempool_destroy(cifs_sm_req_poolp);
1215 kmem_cache_destroy(cifs_sm_req_cachep);
1216}
1217
1218static int
1219cifs_init_mids(void)
1220{
1221 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1222 sizeof(struct mid_q_entry), 0,
1223 SLAB_HWCACHE_ALIGN, NULL);
1224 if (cifs_mid_cachep == NULL)
1225 return -ENOMEM;
1226
1227
1228 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1229 if (cifs_mid_poolp == NULL) {
1230 kmem_cache_destroy(cifs_mid_cachep);
1231 return -ENOMEM;
1232 }
1233
1234 return 0;
1235}
1236
1237static void
1238cifs_destroy_mids(void)
1239{
1240 mempool_destroy(cifs_mid_poolp);
1241 kmem_cache_destroy(cifs_mid_cachep);
1242}
1243
1244static int __init
1245init_cifs(void)
1246{
1247 int rc = 0;
1248 cifs_proc_init();
1249 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1250#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL
1251 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1252 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1253#endif
1254
1255
1256
1257 atomic_set(&sesInfoAllocCount, 0);
1258 atomic_set(&tconInfoAllocCount, 0);
1259 atomic_set(&tcpSesAllocCount, 0);
1260 atomic_set(&tcpSesReconnectCount, 0);
1261 atomic_set(&tconInfoReconnectCount, 0);
1262
1263 atomic_set(&bufAllocCount, 0);
1264 atomic_set(&smBufAllocCount, 0);
1265#ifdef CONFIG_CIFS_STATS2
1266 atomic_set(&totBufAllocCount, 0);
1267 atomic_set(&totSmBufAllocCount, 0);
1268#endif
1269
1270 atomic_set(&midCount, 0);
1271 GlobalCurrentXid = 0;
1272 GlobalTotalActiveXid = 0;
1273 GlobalMaxActiveXid = 0;
1274 spin_lock_init(&cifs_tcp_ses_lock);
1275 spin_lock_init(&cifs_file_list_lock);
1276 spin_lock_init(&GlobalMid_Lock);
1277
1278 if (cifs_max_pending < 2) {
1279 cifs_max_pending = 2;
1280 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1281 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1282 cifs_max_pending = CIFS_MAX_REQ;
1283 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1284 CIFS_MAX_REQ);
1285 }
1286
1287 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1288 if (!cifsiod_wq) {
1289 rc = -ENOMEM;
1290 goto out_clean_proc;
1291 }
1292
1293 rc = cifs_fscache_register();
1294 if (rc)
1295 goto out_destroy_wq;
1296
1297 rc = cifs_init_inodecache();
1298 if (rc)
1299 goto out_unreg_fscache;
1300
1301 rc = cifs_init_mids();
1302 if (rc)
1303 goto out_destroy_inodecache;
1304
1305 rc = cifs_init_request_bufs();
1306 if (rc)
1307 goto out_destroy_mids;
1308
1309#ifdef CONFIG_CIFS_UPCALL
1310 rc = register_key_type(&cifs_spnego_key_type);
1311 if (rc)
1312 goto out_destroy_request_bufs;
1313#endif
1314
1315#ifdef CONFIG_CIFS_ACL
1316 rc = init_cifs_idmap();
1317 if (rc)
1318 goto out_register_key_type;
1319#endif
1320
1321 rc = register_filesystem(&cifs_fs_type);
1322 if (rc)
1323 goto out_init_cifs_idmap;
1324
1325 return 0;
1326
1327out_init_cifs_idmap:
1328#ifdef CONFIG_CIFS_ACL
1329 exit_cifs_idmap();
1330out_register_key_type:
1331#endif
1332#ifdef CONFIG_CIFS_UPCALL
1333 unregister_key_type(&cifs_spnego_key_type);
1334out_destroy_request_bufs:
1335#endif
1336 cifs_destroy_request_bufs();
1337out_destroy_mids:
1338 cifs_destroy_mids();
1339out_destroy_inodecache:
1340 cifs_destroy_inodecache();
1341out_unreg_fscache:
1342 cifs_fscache_unregister();
1343out_destroy_wq:
1344 destroy_workqueue(cifsiod_wq);
1345out_clean_proc:
1346 cifs_proc_clean();
1347 return rc;
1348}
1349
1350static void __exit
1351exit_cifs(void)
1352{
1353 cifs_dbg(NOISY, "exit_cifs\n");
1354 unregister_filesystem(&cifs_fs_type);
1355 cifs_dfs_release_automount_timer();
1356#ifdef CONFIG_CIFS_ACL
1357 exit_cifs_idmap();
1358#endif
1359#ifdef CONFIG_CIFS_UPCALL
1360 unregister_key_type(&cifs_spnego_key_type);
1361#endif
1362 cifs_destroy_request_bufs();
1363 cifs_destroy_mids();
1364 cifs_destroy_inodecache();
1365 cifs_fscache_unregister();
1366 destroy_workqueue(cifsiod_wq);
1367 cifs_proc_clean();
1368}
1369
1370MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1371MODULE_LICENSE("GPL");
1372MODULE_DESCRIPTION
1373 ("VFS to access servers complying with the SNIA CIFS Specification "
1374 "e.g. Samba and Windows");
1375MODULE_VERSION(CIFS_VERSION);
1376module_init(init_cifs)
1377module_exit(exit_cifs)
1378