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