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