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 <net/ipv6.h>
39#include "cifsfs.h"
40#include "cifspdu.h"
41#define DECLARE_GLOBALS_HERE
42#include "cifsglob.h"
43#include "cifsproto.h"
44#include "cifs_debug.h"
45#include "cifs_fs_sb.h"
46#include <linux/mm.h>
47#include <linux/key-type.h>
48#include "cifs_spnego.h"
49#include "fscache.h"
50#define CIFS_MAGIC_NUMBER 0xFF534D42
51
52int cifsFYI = 0;
53int cifsERROR = 1;
54int traceSMB = 0;
55unsigned int oplockEnabled = 1;
56unsigned int experimEnabled = 0;
57unsigned int linuxExtEnabled = 1;
58unsigned int lookupCacheEnabled = 1;
59unsigned int multiuser_mount = 0;
60unsigned int global_secflags = CIFSSEC_DEF;
61
62unsigned int sign_CIFS_PDUs = 1;
63static const struct super_operations cifs_super_ops;
64unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
65module_param(CIFSMaxBufSize, int, 0);
66MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
67 "Default: 16384 Range: 8192 to 130048");
68unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
69module_param(cifs_min_rcv, int, 0);
70MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
71 "1 to 64");
72unsigned int cifs_min_small = 30;
73module_param(cifs_min_small, int, 0);
74MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
75 "Range: 2 to 256");
76unsigned int cifs_max_pending = CIFS_MAX_REQ;
77module_param(cifs_max_pending, int, 0);
78MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
79 "Default: 50 Range: 2 to 256");
80unsigned short echo_retries = 5;
81module_param(echo_retries, ushort, 0644);
82MODULE_PARM_DESC(echo_retries, "Number of echo attempts before giving up and "
83 "reconnecting server. Default: 5. 0 means "
84 "never reconnect.");
85extern mempool_t *cifs_sm_req_poolp;
86extern mempool_t *cifs_req_poolp;
87extern mempool_t *cifs_mid_poolp;
88
89void
90cifs_sb_active(struct super_block *sb)
91{
92 struct cifs_sb_info *server = CIFS_SB(sb);
93
94 if (atomic_inc_return(&server->active) == 1)
95 atomic_inc(&sb->s_active);
96}
97
98void
99cifs_sb_deactive(struct super_block *sb)
100{
101 struct cifs_sb_info *server = CIFS_SB(sb);
102
103 if (atomic_dec_and_test(&server->active))
104 deactivate_super(sb);
105}
106
107static int
108cifs_read_super(struct super_block *sb, void *data,
109 const char *devname, int silent)
110{
111 struct inode *inode;
112 struct cifs_sb_info *cifs_sb;
113 int rc = 0;
114
115
116 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
117 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
118 cifs_sb = CIFS_SB(sb);
119 if (cifs_sb == NULL)
120 return -ENOMEM;
121
122 spin_lock_init(&cifs_sb->tlink_tree_lock);
123 cifs_sb->tlink_tree = RB_ROOT;
124
125 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
126 if (rc) {
127 kfree(cifs_sb);
128 return rc;
129 }
130
131#ifdef CONFIG_CIFS_DFS_UPCALL
132
133
134
135
136
137
138
139 if (data) {
140 int len = strlen(data);
141 cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
142 if (cifs_sb->mountdata == NULL) {
143 bdi_destroy(&cifs_sb->bdi);
144 kfree(sb->s_fs_info);
145 sb->s_fs_info = NULL;
146 return -ENOMEM;
147 }
148 strncpy(cifs_sb->mountdata, data, len + 1);
149 cifs_sb->mountdata[len] = '\0';
150 }
151#endif
152
153 rc = cifs_mount(sb, cifs_sb, data, devname);
154
155 if (rc) {
156 if (!silent)
157 cERROR(1, "cifs_mount failed w/return code = %d", rc);
158 goto out_mount_failed;
159 }
160
161 sb->s_magic = CIFS_MAGIC_NUMBER;
162 sb->s_op = &cifs_super_ops;
163 sb->s_bdi = &cifs_sb->bdi;
164 sb->s_blocksize = CIFS_MAX_MSGSIZE;
165 sb->s_blocksize_bits = 14;
166 inode = cifs_root_iget(sb, ROOT_I);
167
168 if (IS_ERR(inode)) {
169 rc = PTR_ERR(inode);
170 inode = NULL;
171 goto out_no_root;
172 }
173
174 sb->s_root = d_alloc_root(inode);
175
176 if (!sb->s_root) {
177 rc = -ENOMEM;
178 goto out_no_root;
179 }
180
181
182 if (cifs_sb_master_tcon(cifs_sb)->nocase)
183 sb->s_d_op = &cifs_ci_dentry_ops;
184 else
185 sb->s_d_op = &cifs_dentry_ops;
186
187#ifdef CONFIG_CIFS_EXPERIMENTAL
188 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
189 cFYI(1, "export ops supported");
190 sb->s_export_op = &cifs_export_ops;
191 }
192#endif
193
194 return 0;
195
196out_no_root:
197 cERROR(1, "cifs_read_super: get root inode failed");
198 if (inode)
199 iput(inode);
200
201 cifs_umount(sb, cifs_sb);
202
203out_mount_failed:
204 if (cifs_sb) {
205#ifdef CONFIG_CIFS_DFS_UPCALL
206 if (cifs_sb->mountdata) {
207 kfree(cifs_sb->mountdata);
208 cifs_sb->mountdata = NULL;
209 }
210#endif
211 unload_nls(cifs_sb->local_nls);
212 bdi_destroy(&cifs_sb->bdi);
213 kfree(cifs_sb);
214 }
215 return rc;
216}
217
218static void
219cifs_put_super(struct super_block *sb)
220{
221 int rc = 0;
222 struct cifs_sb_info *cifs_sb;
223
224 cFYI(1, "In cifs_put_super");
225 cifs_sb = CIFS_SB(sb);
226 if (cifs_sb == NULL) {
227 cFYI(1, "Empty cifs superblock info passed to unmount");
228 return;
229 }
230
231 rc = cifs_umount(sb, cifs_sb);
232 if (rc)
233 cERROR(1, "cifs_umount failed with return code %d", rc);
234#ifdef CONFIG_CIFS_DFS_UPCALL
235 if (cifs_sb->mountdata) {
236 kfree(cifs_sb->mountdata);
237 cifs_sb->mountdata = NULL;
238 }
239#endif
240
241 unload_nls(cifs_sb->local_nls);
242 bdi_destroy(&cifs_sb->bdi);
243 kfree(cifs_sb);
244}
245
246static int
247cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
248{
249 struct super_block *sb = dentry->d_sb;
250 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
251 struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
252 int rc = -EOPNOTSUPP;
253 int xid;
254
255 xid = GetXid();
256
257 buf->f_type = CIFS_MAGIC_NUMBER;
258
259
260
261
262
263
264
265
266 buf->f_namelen = PATH_MAX;
267 buf->f_files = 0;
268 buf->f_ffree = 0;
269
270
271
272
273 if ((tcon->ses->capabilities & CAP_UNIX) &&
274 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
275 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
276
277
278
279
280
281 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
282 rc = CIFSSMBQFSInfo(xid, tcon, buf);
283
284
285
286
287
288
289 if (rc)
290 rc = SMBOldQFSInfo(xid, tcon, buf);
291
292 FreeXid(xid);
293 return 0;
294}
295
296static int cifs_permission(struct inode *inode, int mask, unsigned int flags)
297{
298 struct cifs_sb_info *cifs_sb;
299
300 if (flags & IPERM_FLAG_RCU)
301 return -ECHILD;
302
303 cifs_sb = CIFS_SB(inode->i_sb);
304
305 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
306 if ((mask & MAY_EXEC) && !execute_ok(inode))
307 return -EACCES;
308 else
309 return 0;
310 } else
311
312
313
314 return generic_permission(inode, mask, flags, NULL);
315}
316
317static struct kmem_cache *cifs_inode_cachep;
318static struct kmem_cache *cifs_req_cachep;
319static struct kmem_cache *cifs_mid_cachep;
320static struct kmem_cache *cifs_sm_req_cachep;
321mempool_t *cifs_sm_req_poolp;
322mempool_t *cifs_req_poolp;
323mempool_t *cifs_mid_poolp;
324
325static struct inode *
326cifs_alloc_inode(struct super_block *sb)
327{
328 struct cifsInodeInfo *cifs_inode;
329 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
330 if (!cifs_inode)
331 return NULL;
332 cifs_inode->cifsAttrs = 0x20;
333 cifs_inode->time = 0;
334
335
336
337 cifs_set_oplock_level(cifs_inode, 0);
338 cifs_inode->delete_pending = false;
339 cifs_inode->invalid_mapping = false;
340 cifs_inode->vfs_inode.i_blkbits = 14;
341 cifs_inode->server_eof = 0;
342 cifs_inode->uniqueid = 0;
343 cifs_inode->createtime = 0;
344
345
346
347
348 INIT_LIST_HEAD(&cifs_inode->openFileList);
349 return &cifs_inode->vfs_inode;
350}
351
352static void cifs_i_callback(struct rcu_head *head)
353{
354 struct inode *inode = container_of(head, struct inode, i_rcu);
355 INIT_LIST_HEAD(&inode->i_dentry);
356 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
357}
358
359static void
360cifs_destroy_inode(struct inode *inode)
361{
362 call_rcu(&inode->i_rcu, cifs_i_callback);
363}
364
365static void
366cifs_evict_inode(struct inode *inode)
367{
368 truncate_inode_pages(&inode->i_data, 0);
369 end_writeback(inode);
370 cifs_fscache_release_inode_cookie(inode);
371}
372
373static void
374cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
375{
376 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
377 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
378
379 seq_printf(s, ",addr=");
380
381 switch (server->dstaddr.ss_family) {
382 case AF_INET:
383 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
384 break;
385 case AF_INET6:
386 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
387 if (sa6->sin6_scope_id)
388 seq_printf(s, "%%%u", sa6->sin6_scope_id);
389 break;
390 default:
391 seq_printf(s, "(unknown)");
392 }
393}
394
395
396
397
398
399
400static int
401cifs_show_options(struct seq_file *s, struct vfsmount *m)
402{
403 struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
404 struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
405 struct sockaddr *srcaddr;
406 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
407
408 seq_printf(s, ",unc=%s", tcon->treeName);
409
410 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
411 seq_printf(s, ",multiuser");
412 else if (tcon->ses->userName)
413 seq_printf(s, ",username=%s", tcon->ses->userName);
414
415 if (tcon->ses->domainName)
416 seq_printf(s, ",domain=%s", tcon->ses->domainName);
417
418 if (srcaddr->sa_family != AF_UNSPEC) {
419 struct sockaddr_in *saddr4;
420 struct sockaddr_in6 *saddr6;
421 saddr4 = (struct sockaddr_in *)srcaddr;
422 saddr6 = (struct sockaddr_in6 *)srcaddr;
423 if (srcaddr->sa_family == AF_INET6)
424 seq_printf(s, ",srcaddr=%pI6c",
425 &saddr6->sin6_addr);
426 else if (srcaddr->sa_family == AF_INET)
427 seq_printf(s, ",srcaddr=%pI4",
428 &saddr4->sin_addr.s_addr);
429 else
430 seq_printf(s, ",srcaddr=BAD-AF:%i",
431 (int)(srcaddr->sa_family));
432 }
433
434 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
435 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
436 seq_printf(s, ",forceuid");
437 else
438 seq_printf(s, ",noforceuid");
439
440 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
441 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
442 seq_printf(s, ",forcegid");
443 else
444 seq_printf(s, ",noforcegid");
445
446 cifs_show_address(s, tcon->ses->server);
447
448 if (!tcon->unix_ext)
449 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
450 cifs_sb->mnt_file_mode,
451 cifs_sb->mnt_dir_mode);
452 if (tcon->seal)
453 seq_printf(s, ",seal");
454 if (tcon->nocase)
455 seq_printf(s, ",nocase");
456 if (tcon->retry)
457 seq_printf(s, ",hard");
458 if (cifs_sb->prepath)
459 seq_printf(s, ",prepath=%s", cifs_sb->prepath);
460 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
461 seq_printf(s, ",posixpaths");
462 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
463 seq_printf(s, ",setuids");
464 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
465 seq_printf(s, ",serverino");
466 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
467 seq_printf(s, ",directio");
468 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
469 seq_printf(s, ",nouser_xattr");
470 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
471 seq_printf(s, ",mapchars");
472 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
473 seq_printf(s, ",sfu");
474 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
475 seq_printf(s, ",nobrl");
476 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
477 seq_printf(s, ",cifsacl");
478 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
479 seq_printf(s, ",dynperm");
480 if (m->mnt_sb->s_flags & MS_POSIXACL)
481 seq_printf(s, ",acl");
482 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
483 seq_printf(s, ",mfsymlinks");
484 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
485 seq_printf(s, ",fsc");
486
487 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
488 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
489
490 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
491
492 return 0;
493}
494
495static void cifs_umount_begin(struct super_block *sb)
496{
497 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
498 struct cifsTconInfo *tcon;
499
500 if (cifs_sb == NULL)
501 return;
502
503 tcon = cifs_sb_master_tcon(cifs_sb);
504
505 spin_lock(&cifs_tcp_ses_lock);
506 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
507
508
509
510 spin_unlock(&cifs_tcp_ses_lock);
511 return;
512 } else if (tcon->tc_count == 1)
513 tcon->tidStatus = CifsExiting;
514 spin_unlock(&cifs_tcp_ses_lock);
515
516
517
518 if (tcon->ses && tcon->ses->server) {
519 cFYI(1, "wake up tasks now - umount begin not complete");
520 wake_up_all(&tcon->ses->server->request_q);
521 wake_up_all(&tcon->ses->server->response_q);
522 msleep(1);
523
524 wake_up_all(&tcon->ses->server->response_q);
525 msleep(1);
526 }
527
528 return;
529}
530
531#ifdef CONFIG_CIFS_STATS2
532static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
533{
534
535 return 0;
536}
537#endif
538
539static int cifs_remount(struct super_block *sb, int *flags, char *data)
540{
541 *flags |= MS_NODIRATIME;
542 return 0;
543}
544
545static int cifs_drop_inode(struct inode *inode)
546{
547 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
548
549
550 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
551 generic_drop_inode(inode);
552}
553
554static const struct super_operations cifs_super_ops = {
555 .put_super = cifs_put_super,
556 .statfs = cifs_statfs,
557 .alloc_inode = cifs_alloc_inode,
558 .destroy_inode = cifs_destroy_inode,
559 .drop_inode = cifs_drop_inode,
560 .evict_inode = cifs_evict_inode,
561
562
563
564
565 .show_options = cifs_show_options,
566 .umount_begin = cifs_umount_begin,
567 .remount_fs = cifs_remount,
568#ifdef CONFIG_CIFS_STATS2
569 .show_stats = cifs_show_stats,
570#endif
571};
572
573static struct dentry *
574cifs_do_mount(struct file_system_type *fs_type,
575 int flags, const char *dev_name, void *data)
576{
577 int rc;
578 struct super_block *sb;
579
580 sb = sget(fs_type, NULL, set_anon_super, NULL);
581
582 cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
583
584 if (IS_ERR(sb))
585 return ERR_CAST(sb);
586
587 sb->s_flags = flags;
588
589 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
590 if (rc) {
591 deactivate_locked_super(sb);
592 return ERR_PTR(rc);
593 }
594 sb->s_flags |= MS_ACTIVE;
595 return dget(sb->s_root);
596}
597
598static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
599 unsigned long nr_segs, loff_t pos)
600{
601 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
602 ssize_t written;
603 int rc;
604
605 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
606
607 if (CIFS_I(inode)->clientCanCacheAll)
608 return written;
609
610 rc = filemap_fdatawrite(inode->i_mapping);
611 if (rc)
612 cFYI(1, "cifs_file_aio_write: %d rc on %p inode", rc, inode);
613
614 return written;
615}
616
617static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
618{
619
620 if (origin == SEEK_END) {
621 int retval;
622
623
624
625
626 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
627
628 retval = cifs_revalidate_file(file);
629 if (retval < 0)
630 return (loff_t)retval;
631 }
632 return generic_file_llseek_unlocked(file, offset, origin);
633}
634
635static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
636{
637
638
639 struct inode *inode = file->f_path.dentry->d_inode;
640 struct cifsFileInfo *cfile = file->private_data;
641
642 if (!(S_ISREG(inode->i_mode)))
643 return -EINVAL;
644
645
646 if (((arg == F_RDLCK) &&
647 (CIFS_I(inode)->clientCanCacheRead)) ||
648 ((arg == F_WRLCK) &&
649 (CIFS_I(inode)->clientCanCacheAll)))
650 return generic_setlease(file, arg, lease);
651 else if (tlink_tcon(cfile->tlink)->local_lease &&
652 !CIFS_I(inode)->clientCanCacheRead)
653
654
655
656
657
658
659
660 return generic_setlease(file, arg, lease);
661 else
662 return -EAGAIN;
663}
664
665struct file_system_type cifs_fs_type = {
666 .owner = THIS_MODULE,
667 .name = "cifs",
668 .mount = cifs_do_mount,
669 .kill_sb = kill_anon_super,
670
671};
672const struct inode_operations cifs_dir_inode_ops = {
673 .create = cifs_create,
674 .lookup = cifs_lookup,
675 .getattr = cifs_getattr,
676 .unlink = cifs_unlink,
677 .link = cifs_hardlink,
678 .mkdir = cifs_mkdir,
679 .rmdir = cifs_rmdir,
680 .rename = cifs_rename,
681 .permission = cifs_permission,
682
683 .setattr = cifs_setattr,
684 .symlink = cifs_symlink,
685 .mknod = cifs_mknod,
686#ifdef CONFIG_CIFS_XATTR
687 .setxattr = cifs_setxattr,
688 .getxattr = cifs_getxattr,
689 .listxattr = cifs_listxattr,
690 .removexattr = cifs_removexattr,
691#endif
692};
693
694const struct inode_operations cifs_file_inode_ops = {
695
696 .setattr = cifs_setattr,
697 .getattr = cifs_getattr,
698 .rename = cifs_rename,
699 .permission = cifs_permission,
700#ifdef CONFIG_CIFS_XATTR
701 .setxattr = cifs_setxattr,
702 .getxattr = cifs_getxattr,
703 .listxattr = cifs_listxattr,
704 .removexattr = cifs_removexattr,
705#endif
706};
707
708const struct inode_operations cifs_symlink_inode_ops = {
709 .readlink = generic_readlink,
710 .follow_link = cifs_follow_link,
711 .put_link = cifs_put_link,
712 .permission = cifs_permission,
713
714
715
716#ifdef CONFIG_CIFS_XATTR
717 .setxattr = cifs_setxattr,
718 .getxattr = cifs_getxattr,
719 .listxattr = cifs_listxattr,
720 .removexattr = cifs_removexattr,
721#endif
722};
723
724const struct file_operations cifs_file_ops = {
725 .read = do_sync_read,
726 .write = do_sync_write,
727 .aio_read = generic_file_aio_read,
728 .aio_write = cifs_file_aio_write,
729 .open = cifs_open,
730 .release = cifs_close,
731 .lock = cifs_lock,
732 .fsync = cifs_fsync,
733 .flush = cifs_flush,
734 .mmap = cifs_file_mmap,
735 .splice_read = generic_file_splice_read,
736 .llseek = cifs_llseek,
737#ifdef CONFIG_CIFS_POSIX
738 .unlocked_ioctl = cifs_ioctl,
739#endif
740 .setlease = cifs_setlease,
741};
742
743const struct file_operations cifs_file_strict_ops = {
744 .read = do_sync_read,
745 .write = do_sync_write,
746 .aio_read = cifs_strict_readv,
747 .aio_write = cifs_strict_writev,
748 .open = cifs_open,
749 .release = cifs_close,
750 .lock = cifs_lock,
751 .fsync = cifs_strict_fsync,
752 .flush = cifs_flush,
753 .mmap = cifs_file_strict_mmap,
754 .splice_read = generic_file_splice_read,
755 .llseek = cifs_llseek,
756#ifdef CONFIG_CIFS_POSIX
757 .unlocked_ioctl = cifs_ioctl,
758#endif
759 .setlease = cifs_setlease,
760};
761
762const struct file_operations cifs_file_direct_ops = {
763
764
765 .read = cifs_user_read,
766 .write = cifs_user_write,
767 .open = cifs_open,
768 .release = cifs_close,
769 .lock = cifs_lock,
770 .fsync = cifs_fsync,
771 .flush = cifs_flush,
772 .mmap = cifs_file_mmap,
773 .splice_read = generic_file_splice_read,
774#ifdef CONFIG_CIFS_POSIX
775 .unlocked_ioctl = cifs_ioctl,
776#endif
777 .llseek = cifs_llseek,
778 .setlease = cifs_setlease,
779};
780
781const struct file_operations cifs_file_nobrl_ops = {
782 .read = do_sync_read,
783 .write = do_sync_write,
784 .aio_read = generic_file_aio_read,
785 .aio_write = cifs_file_aio_write,
786 .open = cifs_open,
787 .release = cifs_close,
788 .fsync = cifs_fsync,
789 .flush = cifs_flush,
790 .mmap = cifs_file_mmap,
791 .splice_read = generic_file_splice_read,
792 .llseek = cifs_llseek,
793#ifdef CONFIG_CIFS_POSIX
794 .unlocked_ioctl = cifs_ioctl,
795#endif
796 .setlease = cifs_setlease,
797};
798
799const struct file_operations cifs_file_strict_nobrl_ops = {
800 .read = do_sync_read,
801 .write = do_sync_write,
802 .aio_read = cifs_strict_readv,
803 .aio_write = cifs_strict_writev,
804 .open = cifs_open,
805 .release = cifs_close,
806 .fsync = cifs_strict_fsync,
807 .flush = cifs_flush,
808 .mmap = cifs_file_strict_mmap,
809 .splice_read = generic_file_splice_read,
810 .llseek = cifs_llseek,
811#ifdef CONFIG_CIFS_POSIX
812 .unlocked_ioctl = cifs_ioctl,
813#endif
814 .setlease = cifs_setlease,
815};
816
817const struct file_operations cifs_file_direct_nobrl_ops = {
818
819
820 .read = cifs_user_read,
821 .write = cifs_user_write,
822 .open = cifs_open,
823 .release = cifs_close,
824 .fsync = cifs_fsync,
825 .flush = cifs_flush,
826 .mmap = cifs_file_mmap,
827 .splice_read = generic_file_splice_read,
828#ifdef CONFIG_CIFS_POSIX
829 .unlocked_ioctl = cifs_ioctl,
830#endif
831 .llseek = cifs_llseek,
832 .setlease = cifs_setlease,
833};
834
835const struct file_operations cifs_dir_ops = {
836 .readdir = cifs_readdir,
837 .release = cifs_closedir,
838 .read = generic_read_dir,
839 .unlocked_ioctl = cifs_ioctl,
840 .llseek = generic_file_llseek,
841};
842
843static void
844cifs_init_once(void *inode)
845{
846 struct cifsInodeInfo *cifsi = inode;
847
848 inode_init_once(&cifsi->vfs_inode);
849 INIT_LIST_HEAD(&cifsi->lockList);
850}
851
852static int
853cifs_init_inodecache(void)
854{
855 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
856 sizeof(struct cifsInodeInfo),
857 0, (SLAB_RECLAIM_ACCOUNT|
858 SLAB_MEM_SPREAD),
859 cifs_init_once);
860 if (cifs_inode_cachep == NULL)
861 return -ENOMEM;
862
863 return 0;
864}
865
866static void
867cifs_destroy_inodecache(void)
868{
869 kmem_cache_destroy(cifs_inode_cachep);
870}
871
872static int
873cifs_init_request_bufs(void)
874{
875 if (CIFSMaxBufSize < 8192) {
876
877
878 CIFSMaxBufSize = 8192;
879 } else if (CIFSMaxBufSize > 1024*127) {
880 CIFSMaxBufSize = 1024 * 127;
881 } else {
882 CIFSMaxBufSize &= 0x1FE00;
883 }
884
885 cifs_req_cachep = kmem_cache_create("cifs_request",
886 CIFSMaxBufSize +
887 MAX_CIFS_HDR_SIZE, 0,
888 SLAB_HWCACHE_ALIGN, NULL);
889 if (cifs_req_cachep == NULL)
890 return -ENOMEM;
891
892 if (cifs_min_rcv < 1)
893 cifs_min_rcv = 1;
894 else if (cifs_min_rcv > 64) {
895 cifs_min_rcv = 64;
896 cERROR(1, "cifs_min_rcv set to maximum (64)");
897 }
898
899 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
900 cifs_req_cachep);
901
902 if (cifs_req_poolp == NULL) {
903 kmem_cache_destroy(cifs_req_cachep);
904 return -ENOMEM;
905 }
906
907
908
909
910
911
912
913
914 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
915 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
916 NULL);
917 if (cifs_sm_req_cachep == NULL) {
918 mempool_destroy(cifs_req_poolp);
919 kmem_cache_destroy(cifs_req_cachep);
920 return -ENOMEM;
921 }
922
923 if (cifs_min_small < 2)
924 cifs_min_small = 2;
925 else if (cifs_min_small > 256) {
926 cifs_min_small = 256;
927 cFYI(1, "cifs_min_small set to maximum (256)");
928 }
929
930 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
931 cifs_sm_req_cachep);
932
933 if (cifs_sm_req_poolp == NULL) {
934 mempool_destroy(cifs_req_poolp);
935 kmem_cache_destroy(cifs_req_cachep);
936 kmem_cache_destroy(cifs_sm_req_cachep);
937 return -ENOMEM;
938 }
939
940 return 0;
941}
942
943static void
944cifs_destroy_request_bufs(void)
945{
946 mempool_destroy(cifs_req_poolp);
947 kmem_cache_destroy(cifs_req_cachep);
948 mempool_destroy(cifs_sm_req_poolp);
949 kmem_cache_destroy(cifs_sm_req_cachep);
950}
951
952static int
953cifs_init_mids(void)
954{
955 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
956 sizeof(struct mid_q_entry), 0,
957 SLAB_HWCACHE_ALIGN, NULL);
958 if (cifs_mid_cachep == NULL)
959 return -ENOMEM;
960
961
962 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
963 if (cifs_mid_poolp == NULL) {
964 kmem_cache_destroy(cifs_mid_cachep);
965 return -ENOMEM;
966 }
967
968 return 0;
969}
970
971static void
972cifs_destroy_mids(void)
973{
974 mempool_destroy(cifs_mid_poolp);
975 kmem_cache_destroy(cifs_mid_cachep);
976}
977
978static int __init
979init_cifs(void)
980{
981 int rc = 0;
982 cifs_proc_init();
983 INIT_LIST_HEAD(&cifs_tcp_ses_list);
984#ifdef CONFIG_CIFS_EXPERIMENTAL
985 INIT_LIST_HEAD(&GlobalDnotifyReqList);
986 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
987#endif
988
989
990
991 atomic_set(&sesInfoAllocCount, 0);
992 atomic_set(&tconInfoAllocCount, 0);
993 atomic_set(&tcpSesAllocCount, 0);
994 atomic_set(&tcpSesReconnectCount, 0);
995 atomic_set(&tconInfoReconnectCount, 0);
996
997 atomic_set(&bufAllocCount, 0);
998 atomic_set(&smBufAllocCount, 0);
999#ifdef CONFIG_CIFS_STATS2
1000 atomic_set(&totBufAllocCount, 0);
1001 atomic_set(&totSmBufAllocCount, 0);
1002#endif
1003
1004 atomic_set(&midCount, 0);
1005 GlobalCurrentXid = 0;
1006 GlobalTotalActiveXid = 0;
1007 GlobalMaxActiveXid = 0;
1008 spin_lock_init(&cifs_tcp_ses_lock);
1009 spin_lock_init(&cifs_file_list_lock);
1010 spin_lock_init(&GlobalMid_Lock);
1011
1012 if (cifs_max_pending < 2) {
1013 cifs_max_pending = 2;
1014 cFYI(1, "cifs_max_pending set to min of 2");
1015 } else if (cifs_max_pending > 256) {
1016 cifs_max_pending = 256;
1017 cFYI(1, "cifs_max_pending set to max of 256");
1018 }
1019
1020 rc = cifs_fscache_register();
1021 if (rc)
1022 goto out_clean_proc;
1023
1024 rc = cifs_init_inodecache();
1025 if (rc)
1026 goto out_unreg_fscache;
1027
1028 rc = cifs_init_mids();
1029 if (rc)
1030 goto out_destroy_inodecache;
1031
1032 rc = cifs_init_request_bufs();
1033 if (rc)
1034 goto out_destroy_mids;
1035
1036 rc = register_filesystem(&cifs_fs_type);
1037 if (rc)
1038 goto out_destroy_request_bufs;
1039#ifdef CONFIG_CIFS_UPCALL
1040 rc = register_key_type(&cifs_spnego_key_type);
1041 if (rc)
1042 goto out_unregister_filesystem;
1043#endif
1044
1045 return 0;
1046
1047#ifdef CONFIG_CIFS_UPCALL
1048out_unregister_filesystem:
1049 unregister_filesystem(&cifs_fs_type);
1050#endif
1051out_destroy_request_bufs:
1052 cifs_destroy_request_bufs();
1053out_destroy_mids:
1054 cifs_destroy_mids();
1055out_destroy_inodecache:
1056 cifs_destroy_inodecache();
1057out_unreg_fscache:
1058 cifs_fscache_unregister();
1059out_clean_proc:
1060 cifs_proc_clean();
1061 return rc;
1062}
1063
1064static void __exit
1065exit_cifs(void)
1066{
1067 cFYI(DBG2, "exit_cifs");
1068 cifs_proc_clean();
1069 cifs_fscache_unregister();
1070#ifdef CONFIG_CIFS_DFS_UPCALL
1071 cifs_dfs_release_automount_timer();
1072#endif
1073#ifdef CONFIG_CIFS_UPCALL
1074 unregister_key_type(&cifs_spnego_key_type);
1075#endif
1076 unregister_filesystem(&cifs_fs_type);
1077 cifs_destroy_inodecache();
1078 cifs_destroy_mids();
1079 cifs_destroy_request_bufs();
1080}
1081
1082MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1083MODULE_LICENSE("GPL");
1084MODULE_DESCRIPTION
1085 ("VFS to access servers complying with the SNIA CIFS Specification "
1086 "e.g. Samba and Windows");
1087MODULE_VERSION(CIFS_VERSION);
1088module_init(init_cifs)
1089module_exit(exit_cifs)
1090