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;
57int traceSMB = 0;
58bool enable_oplocks = true;
59unsigned int linuxExtEnabled = 1;
60unsigned int lookupCacheEnabled = 1;
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 return;
330
331 seq_puts(s, ",sec=");
332
333 switch (ses->sectype) {
334 case LANMAN:
335 seq_puts(s, "lanman");
336 break;
337 case NTLMv2:
338 seq_puts(s, "ntlmv2");
339 break;
340 case NTLM:
341 seq_puts(s, "ntlm");
342 break;
343 case Kerberos:
344 seq_puts(s, "krb5");
345 break;
346 case RawNTLMSSP:
347 seq_puts(s, "ntlmssp");
348 break;
349 default:
350
351 seq_puts(s, "unknown");
352 break;
353 }
354
355 if (ses->sign)
356 seq_puts(s, "i");
357}
358
359static void
360cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
361{
362 seq_puts(s, ",cache=");
363
364 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
365 seq_puts(s, "strict");
366 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
367 seq_puts(s, "none");
368 else
369 seq_puts(s, "loose");
370}
371
372static void
373cifs_show_nls(struct seq_file *s, struct nls_table *cur)
374{
375 struct nls_table *def;
376
377
378 def = load_nls_default();
379 if (def != cur)
380 seq_printf(s, ",iocharset=%s", cur->charset);
381 unload_nls(def);
382}
383
384
385
386
387
388
389static int
390cifs_show_options(struct seq_file *s, struct dentry *root)
391{
392 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
393 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
394 struct sockaddr *srcaddr;
395 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
396
397 seq_printf(s, ",vers=%s", tcon->ses->server->vals->version_string);
398 cifs_show_security(s, tcon->ses);
399 cifs_show_cache_flavor(s, cifs_sb);
400
401 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
402 seq_puts(s, ",multiuser");
403 else if (tcon->ses->user_name)
404 seq_printf(s, ",username=%s", tcon->ses->user_name);
405
406 if (tcon->ses->domainName)
407 seq_printf(s, ",domain=%s", tcon->ses->domainName);
408
409 if (srcaddr->sa_family != AF_UNSPEC) {
410 struct sockaddr_in *saddr4;
411 struct sockaddr_in6 *saddr6;
412 saddr4 = (struct sockaddr_in *)srcaddr;
413 saddr6 = (struct sockaddr_in6 *)srcaddr;
414 if (srcaddr->sa_family == AF_INET6)
415 seq_printf(s, ",srcaddr=%pI6c",
416 &saddr6->sin6_addr);
417 else if (srcaddr->sa_family == AF_INET)
418 seq_printf(s, ",srcaddr=%pI4",
419 &saddr4->sin_addr.s_addr);
420 else
421 seq_printf(s, ",srcaddr=BAD-AF:%i",
422 (int)(srcaddr->sa_family));
423 }
424
425 seq_printf(s, ",uid=%u",
426 from_kuid_munged(&init_user_ns, cifs_sb->mnt_uid));
427 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
428 seq_puts(s, ",forceuid");
429 else
430 seq_puts(s, ",noforceuid");
431
432 seq_printf(s, ",gid=%u",
433 from_kgid_munged(&init_user_ns, cifs_sb->mnt_gid));
434 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
435 seq_puts(s, ",forcegid");
436 else
437 seq_puts(s, ",noforcegid");
438
439 cifs_show_address(s, tcon->ses->server);
440
441 if (!tcon->unix_ext)
442 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
443 cifs_sb->mnt_file_mode,
444 cifs_sb->mnt_dir_mode);
445
446 cifs_show_nls(s, cifs_sb->local_nls);
447
448 if (tcon->seal)
449 seq_puts(s, ",seal");
450 if (tcon->nocase)
451 seq_puts(s, ",nocase");
452 if (tcon->retry)
453 seq_puts(s, ",hard");
454 if (tcon->unix_ext)
455 seq_puts(s, ",unix");
456 else
457 seq_puts(s, ",nounix");
458 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
459 seq_puts(s, ",posixpaths");
460 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
461 seq_puts(s, ",setuids");
462 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
463 seq_puts(s, ",serverino");
464 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
465 seq_puts(s, ",rwpidforward");
466 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
467 seq_puts(s, ",forcemand");
468 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
469 seq_puts(s, ",nouser_xattr");
470 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
471 seq_puts(s, ",mapchars");
472 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
473 seq_puts(s, ",mapposix");
474 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
475 seq_puts(s, ",sfu");
476 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
477 seq_puts(s, ",nobrl");
478 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
479 seq_puts(s, ",cifsacl");
480 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
481 seq_puts(s, ",dynperm");
482 if (root->d_sb->s_flags & MS_POSIXACL)
483 seq_puts(s, ",acl");
484 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
485 seq_puts(s, ",mfsymlinks");
486 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
487 seq_puts(s, ",fsc");
488 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
489 seq_puts(s, ",nostrictsync");
490 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
491 seq_puts(s, ",noperm");
492 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
493 seq_printf(s, ",backupuid=%u",
494 from_kuid_munged(&init_user_ns,
495 cifs_sb->mnt_backupuid));
496 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
497 seq_printf(s, ",backupgid=%u",
498 from_kgid_munged(&init_user_ns,
499 cifs_sb->mnt_backupgid));
500
501 seq_printf(s, ",rsize=%u", cifs_sb->rsize);
502 seq_printf(s, ",wsize=%u", cifs_sb->wsize);
503
504 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
505
506 return 0;
507}
508
509static void cifs_umount_begin(struct super_block *sb)
510{
511 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
512 struct cifs_tcon *tcon;
513
514 if (cifs_sb == NULL)
515 return;
516
517 tcon = cifs_sb_master_tcon(cifs_sb);
518
519 spin_lock(&cifs_tcp_ses_lock);
520 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
521
522
523
524 spin_unlock(&cifs_tcp_ses_lock);
525 return;
526 } else if (tcon->tc_count == 1)
527 tcon->tidStatus = CifsExiting;
528 spin_unlock(&cifs_tcp_ses_lock);
529
530
531
532 if (tcon->ses && tcon->ses->server) {
533 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
534 wake_up_all(&tcon->ses->server->request_q);
535 wake_up_all(&tcon->ses->server->response_q);
536 msleep(1);
537
538 wake_up_all(&tcon->ses->server->response_q);
539 msleep(1);
540 }
541
542 return;
543}
544
545#ifdef CONFIG_CIFS_STATS2
546static int cifs_show_stats(struct seq_file *s, struct dentry *root)
547{
548
549 return 0;
550}
551#endif
552
553static int cifs_remount(struct super_block *sb, int *flags, char *data)
554{
555 sync_filesystem(sb);
556 *flags |= MS_NODIRATIME;
557 return 0;
558}
559
560static int cifs_drop_inode(struct inode *inode)
561{
562 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
563
564
565 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
566 generic_drop_inode(inode);
567}
568
569static const struct super_operations cifs_super_ops = {
570 .statfs = cifs_statfs,
571 .alloc_inode = cifs_alloc_inode,
572 .destroy_inode = cifs_destroy_inode,
573 .drop_inode = cifs_drop_inode,
574 .evict_inode = cifs_evict_inode,
575
576
577
578
579 .show_options = cifs_show_options,
580 .umount_begin = cifs_umount_begin,
581 .remount_fs = cifs_remount,
582#ifdef CONFIG_CIFS_STATS2
583 .show_stats = cifs_show_stats,
584#endif
585};
586
587
588
589
590
591static struct dentry *
592cifs_get_root(struct smb_vol *vol, struct super_block *sb)
593{
594 struct dentry *dentry;
595 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
596 char *full_path = NULL;
597 char *s, *p;
598 char sep;
599
600 full_path = cifs_build_path_to_root(vol, cifs_sb,
601 cifs_sb_master_tcon(cifs_sb));
602 if (full_path == NULL)
603 return ERR_PTR(-ENOMEM);
604
605 cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
606
607 sep = CIFS_DIR_SEP(cifs_sb);
608 dentry = dget(sb->s_root);
609 p = s = full_path;
610
611 do {
612 struct inode *dir = d_inode(dentry);
613 struct dentry *child;
614
615 if (!dir) {
616 dput(dentry);
617 dentry = ERR_PTR(-ENOENT);
618 break;
619 }
620 if (!S_ISDIR(dir->i_mode)) {
621 dput(dentry);
622 dentry = ERR_PTR(-ENOTDIR);
623 break;
624 }
625
626
627 while (*s == sep)
628 s++;
629 if (!*s)
630 break;
631 p = s++;
632
633 while (*s && *s != sep)
634 s++;
635
636 mutex_lock(&dir->i_mutex);
637 child = lookup_one_len(p, dentry, s - p);
638 mutex_unlock(&dir->i_mutex);
639 dput(dentry);
640 dentry = child;
641 } while (!IS_ERR(dentry));
642 kfree(full_path);
643 return dentry;
644}
645
646static int cifs_set_super(struct super_block *sb, void *data)
647{
648 struct cifs_mnt_data *mnt_data = data;
649 sb->s_fs_info = mnt_data->cifs_sb;
650 return set_anon_super(sb, NULL);
651}
652
653static struct dentry *
654cifs_do_mount(struct file_system_type *fs_type,
655 int flags, const char *dev_name, void *data)
656{
657 int rc;
658 struct super_block *sb;
659 struct cifs_sb_info *cifs_sb;
660 struct smb_vol *volume_info;
661 struct cifs_mnt_data mnt_data;
662 struct dentry *root;
663
664 cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
665
666 volume_info = cifs_get_volume_info((char *)data, dev_name);
667 if (IS_ERR(volume_info))
668 return ERR_CAST(volume_info);
669
670 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
671 if (cifs_sb == NULL) {
672 root = ERR_PTR(-ENOMEM);
673 goto out_nls;
674 }
675
676 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
677 if (cifs_sb->mountdata == NULL) {
678 root = ERR_PTR(-ENOMEM);
679 goto out_cifs_sb;
680 }
681
682 cifs_setup_cifs_sb(volume_info, cifs_sb);
683
684 rc = cifs_mount(cifs_sb, volume_info);
685 if (rc) {
686 if (!(flags & MS_SILENT))
687 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
688 rc);
689 root = ERR_PTR(rc);
690 goto out_mountdata;
691 }
692
693 mnt_data.vol = volume_info;
694 mnt_data.cifs_sb = cifs_sb;
695 mnt_data.flags = flags;
696
697
698 flags |= MS_NODIRATIME | MS_NOATIME;
699
700 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
701 if (IS_ERR(sb)) {
702 root = ERR_CAST(sb);
703 cifs_umount(cifs_sb);
704 goto out;
705 }
706
707 if (sb->s_root) {
708 cifs_dbg(FYI, "Use existing superblock\n");
709 cifs_umount(cifs_sb);
710 } else {
711 rc = cifs_read_super(sb);
712 if (rc) {
713 root = ERR_PTR(rc);
714 goto out_super;
715 }
716
717 sb->s_flags |= MS_ACTIVE;
718 }
719
720 root = cifs_get_root(volume_info, sb);
721 if (IS_ERR(root))
722 goto out_super;
723
724 cifs_dbg(FYI, "dentry root is: %p\n", root);
725 goto out;
726
727out_super:
728 deactivate_locked_super(sb);
729out:
730 cifs_cleanup_volume_info(volume_info);
731 return root;
732
733out_mountdata:
734 kfree(cifs_sb->mountdata);
735out_cifs_sb:
736 kfree(cifs_sb);
737out_nls:
738 unload_nls(volume_info->local_nls);
739 goto out;
740}
741
742static ssize_t
743cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
744{
745 ssize_t rc;
746 struct inode *inode = file_inode(iocb->ki_filp);
747
748 rc = cifs_revalidate_mapping(inode);
749 if (rc)
750 return rc;
751
752 return generic_file_read_iter(iocb, iter);
753}
754
755static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
756{
757 struct inode *inode = file_inode(iocb->ki_filp);
758 struct cifsInodeInfo *cinode = CIFS_I(inode);
759 ssize_t written;
760 int rc;
761
762 written = cifs_get_writer(cinode);
763 if (written)
764 return written;
765
766 written = generic_file_write_iter(iocb, from);
767
768 if (CIFS_CACHE_WRITE(CIFS_I(inode)))
769 goto out;
770
771 rc = filemap_fdatawrite(inode->i_mapping);
772 if (rc)
773 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
774 rc, inode);
775
776out:
777 cifs_put_writer(cinode);
778 return written;
779}
780
781static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
782{
783
784
785
786
787 if (whence != SEEK_SET && whence != SEEK_CUR) {
788 int rc;
789 struct inode *inode = file_inode(file);
790
791
792
793
794
795 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
796 inode->i_mapping->nrpages != 0) {
797 rc = filemap_fdatawait(inode->i_mapping);
798 if (rc) {
799 mapping_set_error(inode->i_mapping, rc);
800 return rc;
801 }
802 }
803
804
805
806
807
808 CIFS_I(inode)->time = 0;
809
810 rc = cifs_revalidate_file_attr(file);
811 if (rc < 0)
812 return (loff_t)rc;
813 }
814 return generic_file_llseek(file, offset, whence);
815}
816
817static int
818cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
819{
820
821
822
823
824 struct inode *inode = file_inode(file);
825 struct cifsFileInfo *cfile = file->private_data;
826
827 if (!(S_ISREG(inode->i_mode)))
828 return -EINVAL;
829
830
831 if (arg == F_UNLCK ||
832 ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
833 ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
834 return generic_setlease(file, arg, lease, priv);
835 else if (tlink_tcon(cfile->tlink)->local_lease &&
836 !CIFS_CACHE_READ(CIFS_I(inode)))
837
838
839
840
841
842
843
844
845 return generic_setlease(file, arg, lease, priv);
846 else
847 return -EAGAIN;
848}
849
850struct file_system_type cifs_fs_type = {
851 .owner = THIS_MODULE,
852 .name = "cifs",
853 .mount = cifs_do_mount,
854 .kill_sb = cifs_kill_sb,
855
856};
857MODULE_ALIAS_FS("cifs");
858const struct inode_operations cifs_dir_inode_ops = {
859 .create = cifs_create,
860 .atomic_open = cifs_atomic_open,
861 .lookup = cifs_lookup,
862 .getattr = cifs_getattr,
863 .unlink = cifs_unlink,
864 .link = cifs_hardlink,
865 .mkdir = cifs_mkdir,
866 .rmdir = cifs_rmdir,
867 .rename2 = cifs_rename2,
868 .permission = cifs_permission,
869
870 .setattr = cifs_setattr,
871 .symlink = cifs_symlink,
872 .mknod = cifs_mknod,
873#ifdef CONFIG_CIFS_XATTR
874 .setxattr = cifs_setxattr,
875 .getxattr = cifs_getxattr,
876 .listxattr = cifs_listxattr,
877 .removexattr = cifs_removexattr,
878#endif
879};
880
881const struct inode_operations cifs_file_inode_ops = {
882
883 .setattr = cifs_setattr,
884 .getattr = cifs_getattr,
885 .permission = cifs_permission,
886#ifdef CONFIG_CIFS_XATTR
887 .setxattr = cifs_setxattr,
888 .getxattr = cifs_getxattr,
889 .listxattr = cifs_listxattr,
890 .removexattr = cifs_removexattr,
891#endif
892};
893
894const struct inode_operations cifs_symlink_inode_ops = {
895 .readlink = generic_readlink,
896 .follow_link = cifs_follow_link,
897 .put_link = kfree_put_link,
898 .permission = cifs_permission,
899
900
901
902#ifdef CONFIG_CIFS_XATTR
903 .setxattr = cifs_setxattr,
904 .getxattr = cifs_getxattr,
905 .listxattr = cifs_listxattr,
906 .removexattr = cifs_removexattr,
907#endif
908};
909
910const struct file_operations cifs_file_ops = {
911 .read_iter = cifs_loose_read_iter,
912 .write_iter = cifs_file_write_iter,
913 .open = cifs_open,
914 .release = cifs_close,
915 .lock = cifs_lock,
916 .fsync = cifs_fsync,
917 .flush = cifs_flush,
918 .mmap = cifs_file_mmap,
919 .splice_read = generic_file_splice_read,
920 .llseek = cifs_llseek,
921#ifdef CONFIG_CIFS_POSIX
922 .unlocked_ioctl = cifs_ioctl,
923#endif
924 .setlease = cifs_setlease,
925 .fallocate = cifs_fallocate,
926};
927
928const struct file_operations cifs_file_strict_ops = {
929 .read_iter = cifs_strict_readv,
930 .write_iter = cifs_strict_writev,
931 .open = cifs_open,
932 .release = cifs_close,
933 .lock = cifs_lock,
934 .fsync = cifs_strict_fsync,
935 .flush = cifs_flush,
936 .mmap = cifs_file_strict_mmap,
937 .splice_read = generic_file_splice_read,
938 .llseek = cifs_llseek,
939#ifdef CONFIG_CIFS_POSIX
940 .unlocked_ioctl = cifs_ioctl,
941#endif
942 .setlease = cifs_setlease,
943 .fallocate = cifs_fallocate,
944};
945
946const struct file_operations cifs_file_direct_ops = {
947
948 .read_iter = cifs_user_readv,
949 .write_iter = cifs_user_writev,
950 .open = cifs_open,
951 .release = cifs_close,
952 .lock = cifs_lock,
953 .fsync = cifs_fsync,
954 .flush = cifs_flush,
955 .mmap = cifs_file_mmap,
956 .splice_read = generic_file_splice_read,
957#ifdef CONFIG_CIFS_POSIX
958 .unlocked_ioctl = cifs_ioctl,
959#endif
960 .llseek = cifs_llseek,
961 .setlease = cifs_setlease,
962 .fallocate = cifs_fallocate,
963};
964
965const struct file_operations cifs_file_nobrl_ops = {
966 .read_iter = cifs_loose_read_iter,
967 .write_iter = cifs_file_write_iter,
968 .open = cifs_open,
969 .release = cifs_close,
970 .fsync = cifs_fsync,
971 .flush = cifs_flush,
972 .mmap = cifs_file_mmap,
973 .splice_read = generic_file_splice_read,
974 .llseek = cifs_llseek,
975#ifdef CONFIG_CIFS_POSIX
976 .unlocked_ioctl = cifs_ioctl,
977#endif
978 .setlease = cifs_setlease,
979 .fallocate = cifs_fallocate,
980};
981
982const struct file_operations cifs_file_strict_nobrl_ops = {
983 .read_iter = cifs_strict_readv,
984 .write_iter = cifs_strict_writev,
985 .open = cifs_open,
986 .release = cifs_close,
987 .fsync = cifs_strict_fsync,
988 .flush = cifs_flush,
989 .mmap = cifs_file_strict_mmap,
990 .splice_read = generic_file_splice_read,
991 .llseek = cifs_llseek,
992#ifdef CONFIG_CIFS_POSIX
993 .unlocked_ioctl = cifs_ioctl,
994#endif
995 .setlease = cifs_setlease,
996 .fallocate = cifs_fallocate,
997};
998
999const struct file_operations cifs_file_direct_nobrl_ops = {
1000
1001 .read_iter = cifs_user_readv,
1002 .write_iter = cifs_user_writev,
1003 .open = cifs_open,
1004 .release = cifs_close,
1005 .fsync = cifs_fsync,
1006 .flush = cifs_flush,
1007 .mmap = cifs_file_mmap,
1008 .splice_read = generic_file_splice_read,
1009#ifdef CONFIG_CIFS_POSIX
1010 .unlocked_ioctl = cifs_ioctl,
1011#endif
1012 .llseek = cifs_llseek,
1013 .setlease = cifs_setlease,
1014 .fallocate = cifs_fallocate,
1015};
1016
1017const struct file_operations cifs_dir_ops = {
1018 .iterate = cifs_readdir,
1019 .release = cifs_closedir,
1020 .read = generic_read_dir,
1021 .unlocked_ioctl = cifs_ioctl,
1022 .llseek = generic_file_llseek,
1023};
1024
1025static void
1026cifs_init_once(void *inode)
1027{
1028 struct cifsInodeInfo *cifsi = inode;
1029
1030 inode_init_once(&cifsi->vfs_inode);
1031 init_rwsem(&cifsi->lock_sem);
1032}
1033
1034static int __init
1035cifs_init_inodecache(void)
1036{
1037 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1038 sizeof(struct cifsInodeInfo),
1039 0, (SLAB_RECLAIM_ACCOUNT|
1040 SLAB_MEM_SPREAD),
1041 cifs_init_once);
1042 if (cifs_inode_cachep == NULL)
1043 return -ENOMEM;
1044
1045 return 0;
1046}
1047
1048static void
1049cifs_destroy_inodecache(void)
1050{
1051
1052
1053
1054
1055 rcu_barrier();
1056 kmem_cache_destroy(cifs_inode_cachep);
1057}
1058
1059static int
1060cifs_init_request_bufs(void)
1061{
1062 size_t max_hdr_size = MAX_CIFS_HDR_SIZE;
1063#ifdef CONFIG_CIFS_SMB2
1064
1065
1066
1067
1068 max_hdr_size = MAX_SMB2_HDR_SIZE;
1069#endif
1070 if (CIFSMaxBufSize < 8192) {
1071
1072
1073 CIFSMaxBufSize = 8192;
1074 } else if (CIFSMaxBufSize > 1024*127) {
1075 CIFSMaxBufSize = 1024 * 127;
1076 } else {
1077 CIFSMaxBufSize &= 0x1FE00;
1078 }
1079
1080
1081
1082
1083 cifs_req_cachep = kmem_cache_create("cifs_request",
1084 CIFSMaxBufSize + max_hdr_size, 0,
1085 SLAB_HWCACHE_ALIGN, NULL);
1086 if (cifs_req_cachep == NULL)
1087 return -ENOMEM;
1088
1089 if (cifs_min_rcv < 1)
1090 cifs_min_rcv = 1;
1091 else if (cifs_min_rcv > 64) {
1092 cifs_min_rcv = 64;
1093 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1094 }
1095
1096 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1097 cifs_req_cachep);
1098
1099 if (cifs_req_poolp == NULL) {
1100 kmem_cache_destroy(cifs_req_cachep);
1101 return -ENOMEM;
1102 }
1103
1104
1105
1106
1107
1108
1109
1110
1111 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
1112 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1113 NULL);
1114 if (cifs_sm_req_cachep == NULL) {
1115 mempool_destroy(cifs_req_poolp);
1116 kmem_cache_destroy(cifs_req_cachep);
1117 return -ENOMEM;
1118 }
1119
1120 if (cifs_min_small < 2)
1121 cifs_min_small = 2;
1122 else if (cifs_min_small > 256) {
1123 cifs_min_small = 256;
1124 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1125 }
1126
1127 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1128 cifs_sm_req_cachep);
1129
1130 if (cifs_sm_req_poolp == NULL) {
1131 mempool_destroy(cifs_req_poolp);
1132 kmem_cache_destroy(cifs_req_cachep);
1133 kmem_cache_destroy(cifs_sm_req_cachep);
1134 return -ENOMEM;
1135 }
1136
1137 return 0;
1138}
1139
1140static void
1141cifs_destroy_request_bufs(void)
1142{
1143 mempool_destroy(cifs_req_poolp);
1144 kmem_cache_destroy(cifs_req_cachep);
1145 mempool_destroy(cifs_sm_req_poolp);
1146 kmem_cache_destroy(cifs_sm_req_cachep);
1147}
1148
1149static int
1150cifs_init_mids(void)
1151{
1152 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1153 sizeof(struct mid_q_entry), 0,
1154 SLAB_HWCACHE_ALIGN, NULL);
1155 if (cifs_mid_cachep == NULL)
1156 return -ENOMEM;
1157
1158
1159 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1160 if (cifs_mid_poolp == NULL) {
1161 kmem_cache_destroy(cifs_mid_cachep);
1162 return -ENOMEM;
1163 }
1164
1165 return 0;
1166}
1167
1168static void
1169cifs_destroy_mids(void)
1170{
1171 mempool_destroy(cifs_mid_poolp);
1172 kmem_cache_destroy(cifs_mid_cachep);
1173}
1174
1175static int __init
1176init_cifs(void)
1177{
1178 int rc = 0;
1179 cifs_proc_init();
1180 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1181#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL
1182 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1183 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1184#endif
1185
1186
1187
1188 atomic_set(&sesInfoAllocCount, 0);
1189 atomic_set(&tconInfoAllocCount, 0);
1190 atomic_set(&tcpSesAllocCount, 0);
1191 atomic_set(&tcpSesReconnectCount, 0);
1192 atomic_set(&tconInfoReconnectCount, 0);
1193
1194 atomic_set(&bufAllocCount, 0);
1195 atomic_set(&smBufAllocCount, 0);
1196#ifdef CONFIG_CIFS_STATS2
1197 atomic_set(&totBufAllocCount, 0);
1198 atomic_set(&totSmBufAllocCount, 0);
1199#endif
1200
1201 atomic_set(&midCount, 0);
1202 GlobalCurrentXid = 0;
1203 GlobalTotalActiveXid = 0;
1204 GlobalMaxActiveXid = 0;
1205 spin_lock_init(&cifs_tcp_ses_lock);
1206 spin_lock_init(&cifs_file_list_lock);
1207 spin_lock_init(&GlobalMid_Lock);
1208
1209 if (cifs_max_pending < 2) {
1210 cifs_max_pending = 2;
1211 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1212 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1213 cifs_max_pending = CIFS_MAX_REQ;
1214 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1215 CIFS_MAX_REQ);
1216 }
1217
1218 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1219 if (!cifsiod_wq) {
1220 rc = -ENOMEM;
1221 goto out_clean_proc;
1222 }
1223
1224 rc = cifs_fscache_register();
1225 if (rc)
1226 goto out_destroy_wq;
1227
1228 rc = cifs_init_inodecache();
1229 if (rc)
1230 goto out_unreg_fscache;
1231
1232 rc = cifs_init_mids();
1233 if (rc)
1234 goto out_destroy_inodecache;
1235
1236 rc = cifs_init_request_bufs();
1237 if (rc)
1238 goto out_destroy_mids;
1239
1240#ifdef CONFIG_CIFS_UPCALL
1241 rc = register_key_type(&cifs_spnego_key_type);
1242 if (rc)
1243 goto out_destroy_request_bufs;
1244#endif
1245
1246#ifdef CONFIG_CIFS_ACL
1247 rc = init_cifs_idmap();
1248 if (rc)
1249 goto out_register_key_type;
1250#endif
1251
1252 rc = register_filesystem(&cifs_fs_type);
1253 if (rc)
1254 goto out_init_cifs_idmap;
1255
1256 return 0;
1257
1258out_init_cifs_idmap:
1259#ifdef CONFIG_CIFS_ACL
1260 exit_cifs_idmap();
1261out_register_key_type:
1262#endif
1263#ifdef CONFIG_CIFS_UPCALL
1264 unregister_key_type(&cifs_spnego_key_type);
1265out_destroy_request_bufs:
1266#endif
1267 cifs_destroy_request_bufs();
1268out_destroy_mids:
1269 cifs_destroy_mids();
1270out_destroy_inodecache:
1271 cifs_destroy_inodecache();
1272out_unreg_fscache:
1273 cifs_fscache_unregister();
1274out_destroy_wq:
1275 destroy_workqueue(cifsiod_wq);
1276out_clean_proc:
1277 cifs_proc_clean();
1278 return rc;
1279}
1280
1281static void __exit
1282exit_cifs(void)
1283{
1284 cifs_dbg(NOISY, "exit_cifs\n");
1285 unregister_filesystem(&cifs_fs_type);
1286 cifs_dfs_release_automount_timer();
1287#ifdef CONFIG_CIFS_ACL
1288 exit_cifs_idmap();
1289#endif
1290#ifdef CONFIG_CIFS_UPCALL
1291 unregister_key_type(&cifs_spnego_key_type);
1292#endif
1293 cifs_destroy_request_bufs();
1294 cifs_destroy_mids();
1295 cifs_destroy_inodecache();
1296 cifs_fscache_unregister();
1297 destroy_workqueue(cifsiod_wq);
1298 cifs_proc_clean();
1299}
1300
1301MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1302MODULE_LICENSE("GPL");
1303MODULE_DESCRIPTION
1304 ("VFS to access servers complying with the SNIA CIFS Specification "
1305 "e.g. Samba and Windows");
1306MODULE_VERSION(CIFS_VERSION);
1307module_init(init_cifs)
1308module_exit(exit_cifs)
1309