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