4 * Copyright (C) International Business Machines Corp., 2002,2004
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * Common Internet FileSystem (CIFS) client
9 * This library is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU Lesser General Public License as published
11 * by the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 /* Note that BB means BUGBUG (ie something to fix eventually) */
26 #include <linux/module.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>
38 #define DECLARE_GLOBALS_HERE
40 #include "cifsproto.h"
41 #include "cifs_debug.h"
42 #include "cifs_fs_sb.h"
44 #define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
46 #ifdef CONFIG_CIFS_QUOTA
47 static struct quotactl_ops cifs_quotactl_ops
;
53 unsigned int oplockEnabled
= 1;
54 unsigned int experimEnabled
= 0;
55 unsigned int linuxExtEnabled
= 1;
56 unsigned int lookupCacheEnabled
= 1;
57 unsigned int multiuser_mount
= 0;
58 unsigned int extended_security
= 0;
59 unsigned int ntlmv2_support
= 0;
60 unsigned int sign_CIFS_PDUs
= 1;
61 extern struct task_struct
* oplockThread
; /* remove sparse warning */
62 struct task_struct
* oplockThread
= NULL
;
63 extern struct task_struct
* dnotifyThread
; /* remove sparse warning */
64 struct task_struct
* dnotifyThread
= NULL
;
65 unsigned int CIFSMaxBufSize
= CIFS_MAX_MSGSIZE
;
66 module_param(CIFSMaxBufSize
, int, 0);
67 MODULE_PARM_DESC(CIFSMaxBufSize
,"Network buffer size (not including header). Default: 16384 Range: 8192 to 130048");
68 unsigned int cifs_min_rcv
= CIFS_MIN_RCV_POOL
;
69 module_param(cifs_min_rcv
, int, 0);
70 MODULE_PARM_DESC(cifs_min_rcv
,"Network buffers in pool. Default: 4 Range: 1 to 64");
71 unsigned int cifs_min_small
= 30;
72 module_param(cifs_min_small
, int, 0);
73 MODULE_PARM_DESC(cifs_min_small
,"Small network buffers in pool. Default: 30 Range: 2 to 256");
74 unsigned int cifs_max_pending
= CIFS_MAX_REQ
;
75 module_param(cifs_max_pending
, int, 0);
76 MODULE_PARM_DESC(cifs_max_pending
,"Simultaneous requests to server. Default: 50 Range: 2 to 256");
78 static DECLARE_COMPLETION(cifs_oplock_exited
);
79 static DECLARE_COMPLETION(cifs_dnotify_exited
);
81 extern mempool_t
*cifs_sm_req_poolp
;
82 extern mempool_t
*cifs_req_poolp
;
83 extern mempool_t
*cifs_mid_poolp
;
85 extern kmem_cache_t
*cifs_oplock_cachep
;
88 cifs_read_super(struct super_block
*sb
, void *data
,
89 const char *devname
, int silent
)
92 struct cifs_sb_info
*cifs_sb
;
95 sb
->s_flags
|= MS_NODIRATIME
; /* and probably even noatime */
96 sb
->s_fs_info
= kzalloc(sizeof(struct cifs_sb_info
),GFP_KERNEL
);
97 cifs_sb
= CIFS_SB(sb
);
101 rc
= cifs_mount(sb
, cifs_sb
, data
, devname
);
106 ("cifs_mount failed w/return code = %d", rc
));
107 goto out_mount_failed
;
110 sb
->s_magic
= CIFS_MAGIC_NUMBER
;
111 sb
->s_op
= &cifs_super_ops
;
112 /* if(cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
113 sb->s_blocksize = cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
114 #ifdef CONFIG_CIFS_QUOTA
115 sb
->s_qcop
= &cifs_quotactl_ops
;
117 sb
->s_blocksize
= CIFS_MAX_MSGSIZE
;
118 sb
->s_blocksize_bits
= 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
119 inode
= iget(sb
, ROOT_I
);
126 sb
->s_root
= d_alloc_root(inode
);
136 cERROR(1, ("cifs_read_super: get root inode failed"));
142 if(cifs_sb
->local_nls
)
143 unload_nls(cifs_sb
->local_nls
);
150 cifs_put_super(struct super_block
*sb
)
153 struct cifs_sb_info
*cifs_sb
;
155 cFYI(1, ("In cifs_put_super"));
156 cifs_sb
= CIFS_SB(sb
);
157 if(cifs_sb
== NULL
) {
158 cFYI(1,("Empty cifs superblock info passed to unmount"));
161 rc
= cifs_umount(sb
, cifs_sb
);
163 cERROR(1, ("cifs_umount failed with return code %d", rc
));
165 unload_nls(cifs_sb
->local_nls
);
171 cifs_statfs(struct super_block
*sb
, struct kstatfs
*buf
)
174 int rc
= -EOPNOTSUPP
;
175 struct cifs_sb_info
*cifs_sb
;
176 struct cifsTconInfo
*pTcon
;
180 cifs_sb
= CIFS_SB(sb
);
181 pTcon
= cifs_sb
->tcon
;
183 buf
->f_type
= CIFS_MAGIC_NUMBER
;
185 /* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */
186 buf
->f_namelen
= PATH_MAX
; /* PATH_MAX may be too long - it would
187 presumably be total path, but note
188 that some servers (includinng Samba 3)
189 have a shorter maximum path */
190 buf
->f_files
= 0; /* undefined */
191 buf
->f_ffree
= 0; /* unlimited */
193 #ifdef CONFIG_CIFS_EXPERIMENTAL
194 /* BB we could add a second check for a QFS Unix capability bit */
195 /* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */
196 if ((pTcon
->ses
->capabilities
& CAP_UNIX
) && (CIFS_POSIX_EXTENSIONS
&
197 le64_to_cpu(pTcon
->fsUnixInfo
.Capability
)))
198 rc
= CIFSSMBQFSPosixInfo(xid
, pTcon
, buf
);
200 /* Only need to call the old QFSInfo if failed
203 #endif /* CIFS_EXPERIMENTAL */
204 rc
= CIFSSMBQFSInfo(xid
, pTcon
, buf
);
206 /* Old Windows servers do not support level 103, retry with level
207 one if old server failed the previous call */
209 rc
= SMBOldQFSInfo(xid
, pTcon
, buf
);
214 /* BB get from info in tcon struct at mount time call to QFSAttrInfo */
216 return 0; /* always return success? what if volume is no
220 static int cifs_permission(struct inode
* inode
, int mask
, struct nameidata
*nd
)
222 struct cifs_sb_info
*cifs_sb
;
224 cifs_sb
= CIFS_SB(inode
->i_sb
);
226 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
) {
228 } else /* file mode might have been restricted at mount time
229 on the client (above and beyond ACL on servers) for
230 servers which do not support setting and viewing mode bits,
231 so allowing client to check permissions is useful */
232 return generic_permission(inode
, mask
, NULL
);
235 static kmem_cache_t
*cifs_inode_cachep
;
236 static kmem_cache_t
*cifs_req_cachep
;
237 static kmem_cache_t
*cifs_mid_cachep
;
238 kmem_cache_t
*cifs_oplock_cachep
;
239 static kmem_cache_t
*cifs_sm_req_cachep
;
240 mempool_t
*cifs_sm_req_poolp
;
241 mempool_t
*cifs_req_poolp
;
242 mempool_t
*cifs_mid_poolp
;
244 static struct inode
*
245 cifs_alloc_inode(struct super_block
*sb
)
247 struct cifsInodeInfo
*cifs_inode
;
248 cifs_inode
= kmem_cache_alloc(cifs_inode_cachep
, SLAB_KERNEL
);
251 cifs_inode
->cifsAttrs
= 0x20; /* default */
252 atomic_set(&cifs_inode
->inUse
, 0);
253 cifs_inode
->time
= 0;
254 /* Until the file is open and we have gotten oplock
255 info back from the server, can not assume caching of
256 file data or metadata */
257 cifs_inode
->clientCanCacheRead
= FALSE
;
258 cifs_inode
->clientCanCacheAll
= FALSE
;
259 cifs_inode
->vfs_inode
.i_blksize
= CIFS_MAX_MSGSIZE
;
260 cifs_inode
->vfs_inode
.i_blkbits
= 14; /* 2**14 = CIFS_MAX_MSGSIZE */
261 cifs_inode
->vfs_inode
.i_flags
= S_NOATIME
| S_NOCMTIME
;
262 INIT_LIST_HEAD(&cifs_inode
->openFileList
);
263 return &cifs_inode
->vfs_inode
;
267 cifs_destroy_inode(struct inode
*inode
)
269 kmem_cache_free(cifs_inode_cachep
, CIFS_I(inode
));
273 * cifs_show_options() is for displaying mount options in /proc/mounts.
274 * Not all settable options are displayed but most of the important
278 cifs_show_options(struct seq_file
*s
, struct vfsmount
*m
)
280 struct cifs_sb_info
*cifs_sb
;
282 cifs_sb
= CIFS_SB(m
->mnt_sb
);
286 seq_printf(s
, ",unc=%s", cifs_sb
->tcon
->treeName
);
287 if (cifs_sb
->tcon
->ses
) {
288 if (cifs_sb
->tcon
->ses
->userName
)
289 seq_printf(s
, ",username=%s",
290 cifs_sb
->tcon
->ses
->userName
);
291 if(cifs_sb
->tcon
->ses
->domainName
)
292 seq_printf(s
, ",domain=%s",
293 cifs_sb
->tcon
->ses
->domainName
);
296 seq_printf(s
, ",rsize=%d",cifs_sb
->rsize
);
297 seq_printf(s
, ",wsize=%d",cifs_sb
->wsize
);
302 #ifdef CONFIG_CIFS_QUOTA
303 int cifs_xquota_set(struct super_block
* sb
, int quota_type
, qid_t qid
,
304 struct fs_disk_quota
* pdquota
)
308 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
309 struct cifsTconInfo
*pTcon
;
312 pTcon
= cifs_sb
->tcon
;
319 cFYI(1,("set type: 0x%x id: %d",quota_type
,qid
));
328 int cifs_xquota_get(struct super_block
* sb
, int quota_type
, qid_t qid
,
329 struct fs_disk_quota
* pdquota
)
333 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
334 struct cifsTconInfo
*pTcon
;
337 pTcon
= cifs_sb
->tcon
;
343 cFYI(1,("set type: 0x%x id: %d",quota_type
,qid
));
352 int cifs_xstate_set(struct super_block
* sb
, unsigned int flags
, int operation
)
356 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
357 struct cifsTconInfo
*pTcon
;
360 pTcon
= cifs_sb
->tcon
;
366 cFYI(1,("flags: 0x%x operation: 0x%x",flags
,operation
));
375 int cifs_xstate_get(struct super_block
* sb
, struct fs_quota_stat
*qstats
)
379 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
380 struct cifsTconInfo
*pTcon
;
383 pTcon
= cifs_sb
->tcon
;
389 cFYI(1,("pqstats %p",qstats
));
398 static struct quotactl_ops cifs_quotactl_ops
= {
399 .set_xquota
= cifs_xquota_set
,
400 .get_xquota
= cifs_xquota_set
,
401 .set_xstate
= cifs_xstate_set
,
402 .get_xstate
= cifs_xstate_get
,
406 #ifdef CONFIG_CIFS_EXPERIMENTAL
407 static void cifs_umount_begin(struct super_block
* sblock
)
409 struct cifs_sb_info
*cifs_sb
;
410 struct cifsTconInfo
* tcon
;
412 cifs_sb
= CIFS_SB(sblock
);
416 tcon
= cifs_sb
->tcon
;
419 down(&tcon
->tconSem
);
420 if (atomic_read(&tcon
->useCount
) == 1)
421 tcon
->tidStatus
= CifsExiting
;
424 /* cancel_brl_requests(tcon); */
425 /* cancel_notify_requests(tcon); */
426 if(tcon
->ses
&& tcon
->ses
->server
)
428 cFYI(1,("wake up tasks now - umount begin not complete"));
429 wake_up_all(&tcon
->ses
->server
->request_q
);
430 wake_up_all(&tcon
->ses
->server
->response_q
);
431 msleep(1); /* yield */
432 /* we have to kick the requests once more */
433 wake_up_all(&tcon
->ses
->server
->response_q
);
436 /* BB FIXME - finish add checks for tidStatus BB */
442 static int cifs_remount(struct super_block
*sb
, int *flags
, char *data
)
444 *flags
|= MS_NODIRATIME
;
448 struct super_operations cifs_super_ops
= {
449 .read_inode
= cifs_read_inode
,
450 .put_super
= cifs_put_super
,
451 .statfs
= cifs_statfs
,
452 .alloc_inode
= cifs_alloc_inode
,
453 .destroy_inode
= cifs_destroy_inode
,
454 /* .drop_inode = generic_delete_inode,
455 .delete_inode = cifs_delete_inode, *//* Do not need the above two functions
456 unless later we add lazy close of inodes or unless the kernel forgets to call
457 us with the same number of releases (closes) as opens */
458 .show_options
= cifs_show_options
,
459 #ifdef CONFIG_CIFS_EXPERIMENTAL
460 .umount_begin
= cifs_umount_begin
,
462 .remount_fs
= cifs_remount
,
465 static struct super_block
*
466 cifs_get_sb(struct file_system_type
*fs_type
,
467 int flags
, const char *dev_name
, void *data
)
470 struct super_block
*sb
= sget(fs_type
, NULL
, set_anon_super
, NULL
);
472 cFYI(1, ("Devname: %s flags: %d ", dev_name
, flags
));
479 rc
= cifs_read_super(sb
, data
, dev_name
, flags
& MS_SILENT
? 1 : 0);
481 up_write(&sb
->s_umount
);
482 deactivate_super(sb
);
485 sb
->s_flags
|= MS_ACTIVE
;
489 static ssize_t
cifs_file_writev(struct file
*file
, const struct iovec
*iov
,
490 unsigned long nr_segs
, loff_t
*ppos
)
492 struct inode
*inode
= file
->f_dentry
->d_inode
;
495 written
= generic_file_writev(file
, iov
, nr_segs
, ppos
);
496 if (!CIFS_I(inode
)->clientCanCacheAll
)
497 filemap_fdatawrite(inode
->i_mapping
);
501 static ssize_t
cifs_file_aio_write(struct kiocb
*iocb
, const char __user
*buf
,
502 size_t count
, loff_t pos
)
504 struct inode
*inode
= iocb
->ki_filp
->f_dentry
->d_inode
;
507 written
= generic_file_aio_write(iocb
, buf
, count
, pos
);
508 if (!CIFS_I(inode
)->clientCanCacheAll
)
509 filemap_fdatawrite(inode
->i_mapping
);
513 static loff_t
cifs_llseek(struct file
*file
, loff_t offset
, int origin
)
515 /* origin == SEEK_END => we must revalidate the cached file length */
517 int retval
= cifs_revalidate(file
->f_dentry
);
519 return (loff_t
)retval
;
521 return remote_llseek(file
, offset
, origin
);
524 static struct file_system_type cifs_fs_type
= {
525 .owner
= THIS_MODULE
,
527 .get_sb
= cifs_get_sb
,
528 .kill_sb
= kill_anon_super
,
531 struct inode_operations cifs_dir_inode_ops
= {
532 .create
= cifs_create
,
533 .lookup
= cifs_lookup
,
534 .getattr
= cifs_getattr
,
535 .unlink
= cifs_unlink
,
536 .link
= cifs_hardlink
,
539 .rename
= cifs_rename
,
540 .permission
= cifs_permission
,
541 /* revalidate:cifs_revalidate, */
542 .setattr
= cifs_setattr
,
543 .symlink
= cifs_symlink
,
545 #ifdef CONFIG_CIFS_XATTR
546 .setxattr
= cifs_setxattr
,
547 .getxattr
= cifs_getxattr
,
548 .listxattr
= cifs_listxattr
,
549 .removexattr
= cifs_removexattr
,
553 struct inode_operations cifs_file_inode_ops
= {
554 /* revalidate:cifs_revalidate, */
555 .setattr
= cifs_setattr
,
556 .getattr
= cifs_getattr
, /* do we need this anymore? */
557 .rename
= cifs_rename
,
558 .permission
= cifs_permission
,
559 #ifdef CONFIG_CIFS_XATTR
560 .setxattr
= cifs_setxattr
,
561 .getxattr
= cifs_getxattr
,
562 .listxattr
= cifs_listxattr
,
563 .removexattr
= cifs_removexattr
,
567 struct inode_operations cifs_symlink_inode_ops
= {
568 .readlink
= generic_readlink
,
569 .follow_link
= cifs_follow_link
,
570 .put_link
= cifs_put_link
,
571 .permission
= cifs_permission
,
572 /* BB add the following two eventually */
573 /* revalidate: cifs_revalidate,
574 setattr: cifs_notify_change, *//* BB do we need notify change */
575 #ifdef CONFIG_CIFS_XATTR
576 .setxattr
= cifs_setxattr
,
577 .getxattr
= cifs_getxattr
,
578 .listxattr
= cifs_listxattr
,
579 .removexattr
= cifs_removexattr
,
583 const struct file_operations cifs_file_ops
= {
584 .read
= do_sync_read
,
585 .write
= do_sync_write
,
586 .readv
= generic_file_readv
,
587 .writev
= cifs_file_writev
,
588 .aio_read
= generic_file_aio_read
,
589 .aio_write
= cifs_file_aio_write
,
591 .release
= cifs_close
,
595 .mmap
= cifs_file_mmap
,
596 .sendfile
= generic_file_sendfile
,
597 .llseek
= cifs_llseek
,
598 #ifdef CONFIG_CIFS_POSIX
600 #endif /* CONFIG_CIFS_POSIX */
602 #ifdef CONFIG_CIFS_EXPERIMENTAL
603 .dir_notify
= cifs_dir_notify
,
604 #endif /* CONFIG_CIFS_EXPERIMENTAL */
607 const struct file_operations cifs_file_direct_ops
= {
608 /* no mmap, no aio, no readv -
609 BB reevaluate whether they can be done with directio, no cache */
610 .read
= cifs_user_read
,
611 .write
= cifs_user_write
,
613 .release
= cifs_close
,
617 .sendfile
= generic_file_sendfile
, /* BB removeme BB */
618 #ifdef CONFIG_CIFS_POSIX
620 #endif /* CONFIG_CIFS_POSIX */
621 .llseek
= cifs_llseek
,
622 #ifdef CONFIG_CIFS_EXPERIMENTAL
623 .dir_notify
= cifs_dir_notify
,
624 #endif /* CONFIG_CIFS_EXPERIMENTAL */
626 const struct file_operations cifs_file_nobrl_ops
= {
627 .read
= do_sync_read
,
628 .write
= do_sync_write
,
629 .readv
= generic_file_readv
,
630 .writev
= cifs_file_writev
,
631 .aio_read
= generic_file_aio_read
,
632 .aio_write
= cifs_file_aio_write
,
634 .release
= cifs_close
,
637 .mmap
= cifs_file_mmap
,
638 .sendfile
= generic_file_sendfile
,
639 .llseek
= cifs_llseek
,
640 #ifdef CONFIG_CIFS_POSIX
642 #endif /* CONFIG_CIFS_POSIX */
644 #ifdef CONFIG_CIFS_EXPERIMENTAL
645 .dir_notify
= cifs_dir_notify
,
646 #endif /* CONFIG_CIFS_EXPERIMENTAL */
649 const struct file_operations cifs_file_direct_nobrl_ops
= {
650 /* no mmap, no aio, no readv -
651 BB reevaluate whether they can be done with directio, no cache */
652 .read
= cifs_user_read
,
653 .write
= cifs_user_write
,
655 .release
= cifs_close
,
658 .sendfile
= generic_file_sendfile
, /* BB removeme BB */
659 #ifdef CONFIG_CIFS_POSIX
661 #endif /* CONFIG_CIFS_POSIX */
662 .llseek
= cifs_llseek
,
663 #ifdef CONFIG_CIFS_EXPERIMENTAL
664 .dir_notify
= cifs_dir_notify
,
665 #endif /* CONFIG_CIFS_EXPERIMENTAL */
668 const struct file_operations cifs_dir_ops
= {
669 .readdir
= cifs_readdir
,
670 .release
= cifs_closedir
,
671 .read
= generic_read_dir
,
672 #ifdef CONFIG_CIFS_EXPERIMENTAL
673 .dir_notify
= cifs_dir_notify
,
674 #endif /* CONFIG_CIFS_EXPERIMENTAL */
679 cifs_init_once(void *inode
, kmem_cache_t
* cachep
, unsigned long flags
)
681 struct cifsInodeInfo
*cifsi
= inode
;
683 if ((flags
& (SLAB_CTOR_VERIFY
| SLAB_CTOR_CONSTRUCTOR
)) ==
684 SLAB_CTOR_CONSTRUCTOR
) {
685 inode_init_once(&cifsi
->vfs_inode
);
686 INIT_LIST_HEAD(&cifsi
->lockList
);
691 cifs_init_inodecache(void)
693 cifs_inode_cachep
= kmem_cache_create("cifs_inode_cache",
694 sizeof (struct cifsInodeInfo
),
695 0, (SLAB_RECLAIM_ACCOUNT
|
697 cifs_init_once
, NULL
);
698 if (cifs_inode_cachep
== NULL
)
705 cifs_destroy_inodecache(void)
707 if (kmem_cache_destroy(cifs_inode_cachep
))
708 printk(KERN_WARNING
"cifs_inode_cache: error freeing\n");
712 cifs_init_request_bufs(void)
714 if(CIFSMaxBufSize
< 8192) {
715 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
716 Unicode path name has to fit in any SMB/CIFS path based frames */
717 CIFSMaxBufSize
= 8192;
718 } else if (CIFSMaxBufSize
> 1024*127) {
719 CIFSMaxBufSize
= 1024 * 127;
721 CIFSMaxBufSize
&= 0x1FE00; /* Round size to even 512 byte mult*/
723 /* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
724 cifs_req_cachep
= kmem_cache_create("cifs_request",
726 MAX_CIFS_HDR_SIZE
, 0,
727 SLAB_HWCACHE_ALIGN
, NULL
, NULL
);
728 if (cifs_req_cachep
== NULL
)
733 else if (cifs_min_rcv
> 64) {
735 cERROR(1,("cifs_min_rcv set to maximum (64)"));
738 cifs_req_poolp
= mempool_create_slab_pool(cifs_min_rcv
,
741 if(cifs_req_poolp
== NULL
) {
742 kmem_cache_destroy(cifs_req_cachep
);
745 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
746 almost all handle based requests (but not write response, nor is it
747 sufficient for path based requests). A smaller size would have
748 been more efficient (compacting multiple slab items on one 4k page)
749 for the case in which debug was on, but this larger size allows
750 more SMBs to use small buffer alloc and is still much more
751 efficient to alloc 1 per page off the slab compared to 17K (5page)
752 alloc of large cifs buffers even when page debugging is on */
753 cifs_sm_req_cachep
= kmem_cache_create("cifs_small_rq",
754 MAX_CIFS_SMALL_BUFFER_SIZE
, 0, SLAB_HWCACHE_ALIGN
,
756 if (cifs_sm_req_cachep
== NULL
) {
757 mempool_destroy(cifs_req_poolp
);
758 kmem_cache_destroy(cifs_req_cachep
);
762 if(cifs_min_small
< 2)
764 else if (cifs_min_small
> 256) {
765 cifs_min_small
= 256;
766 cFYI(1,("cifs_min_small set to maximum (256)"));
769 cifs_sm_req_poolp
= mempool_create_slab_pool(cifs_min_small
,
772 if(cifs_sm_req_poolp
== NULL
) {
773 mempool_destroy(cifs_req_poolp
);
774 kmem_cache_destroy(cifs_req_cachep
);
775 kmem_cache_destroy(cifs_sm_req_cachep
);
783 cifs_destroy_request_bufs(void)
785 mempool_destroy(cifs_req_poolp
);
786 if (kmem_cache_destroy(cifs_req_cachep
))
788 "cifs_destroy_request_cache: error not all structures were freed\n");
789 mempool_destroy(cifs_sm_req_poolp
);
790 if (kmem_cache_destroy(cifs_sm_req_cachep
))
792 "cifs_destroy_request_cache: cifs_small_rq free error\n");
798 cifs_mid_cachep
= kmem_cache_create("cifs_mpx_ids",
799 sizeof (struct mid_q_entry
), 0,
800 SLAB_HWCACHE_ALIGN
, NULL
, NULL
);
801 if (cifs_mid_cachep
== NULL
)
804 /* 3 is a reasonable minimum number of simultaneous operations */
805 cifs_mid_poolp
= mempool_create_slab_pool(3, cifs_mid_cachep
);
806 if(cifs_mid_poolp
== NULL
) {
807 kmem_cache_destroy(cifs_mid_cachep
);
811 cifs_oplock_cachep
= kmem_cache_create("cifs_oplock_structs",
812 sizeof (struct oplock_q_entry
), 0,
813 SLAB_HWCACHE_ALIGN
, NULL
, NULL
);
814 if (cifs_oplock_cachep
== NULL
) {
815 kmem_cache_destroy(cifs_mid_cachep
);
816 mempool_destroy(cifs_mid_poolp
);
824 cifs_destroy_mids(void)
826 mempool_destroy(cifs_mid_poolp
);
827 if (kmem_cache_destroy(cifs_mid_cachep
))
829 "cifs_destroy_mids: error not all structures were freed\n");
831 if (kmem_cache_destroy(cifs_oplock_cachep
))
833 "error not all oplock structures were freed\n");
836 static int cifs_oplock_thread(void * dummyarg
)
838 struct oplock_q_entry
* oplock_item
;
839 struct cifsTconInfo
*pTcon
;
840 struct inode
* inode
;
844 daemonize("cifsoplockd");
845 allow_signal(SIGTERM
);
847 oplockThread
= current
;
852 spin_lock(&GlobalMid_Lock
);
853 if(list_empty(&GlobalOplock_Q
)) {
854 spin_unlock(&GlobalMid_Lock
);
855 set_current_state(TASK_INTERRUPTIBLE
);
856 schedule_timeout(39*HZ
);
858 oplock_item
= list_entry(GlobalOplock_Q
.next
,
859 struct oplock_q_entry
, qhead
);
861 cFYI(1,("found oplock item to write out"));
862 pTcon
= oplock_item
->tcon
;
863 inode
= oplock_item
->pinode
;
864 netfid
= oplock_item
->netfid
;
865 spin_unlock(&GlobalMid_Lock
);
866 DeleteOplockQEntry(oplock_item
);
867 /* can not grab inode sem here since it would
868 deadlock when oplock received on delete
869 since vfs_unlink holds the i_mutex across
871 /* mutex_lock(&inode->i_mutex);*/
872 if (S_ISREG(inode
->i_mode
)) {
873 rc
= filemap_fdatawrite(inode
->i_mapping
);
874 if(CIFS_I(inode
)->clientCanCacheRead
== 0) {
875 filemap_fdatawait(inode
->i_mapping
);
876 invalidate_remote_inode(inode
);
880 /* mutex_unlock(&inode->i_mutex);*/
882 CIFS_I(inode
)->write_behind_rc
= rc
;
883 cFYI(1,("Oplock flush inode %p rc %d",inode
,rc
));
885 /* releasing a stale oplock after recent reconnection
886 of smb session using a now incorrect file
887 handle is not a data integrity issue but do
888 not bother sending an oplock release if session
889 to server still is disconnected since oplock
890 already released by the server in that case */
891 if(pTcon
->tidStatus
!= CifsNeedReconnect
) {
892 rc
= CIFSSMBLock(0, pTcon
, netfid
,
893 0 /* len */ , 0 /* offset */, 0,
894 0, LOCKING_ANDX_OPLOCK_RELEASE
,
896 cFYI(1,("Oplock release rc = %d ",rc
));
899 spin_unlock(&GlobalMid_Lock
);
900 set_current_state(TASK_INTERRUPTIBLE
);
901 schedule_timeout(1); /* yield in case q were corrupt */
903 } while(!signal_pending(current
));
905 complete_and_exit (&cifs_oplock_exited
, 0);
908 static int cifs_dnotify_thread(void * dummyarg
)
910 struct list_head
*tmp
;
911 struct cifsSesInfo
*ses
;
913 daemonize("cifsdnotifyd");
914 allow_signal(SIGTERM
);
916 dnotifyThread
= current
;
920 set_current_state(TASK_INTERRUPTIBLE
);
921 schedule_timeout(15*HZ
);
922 read_lock(&GlobalSMBSeslock
);
923 /* check if any stuck requests that need
924 to be woken up and wakeq so the
925 thread can wake up and error out */
926 list_for_each(tmp
, &GlobalSMBSessionList
) {
927 ses
= list_entry(tmp
, struct cifsSesInfo
,
929 if(ses
&& ses
->server
&&
930 atomic_read(&ses
->server
->inFlight
))
931 wake_up_all(&ses
->server
->response_q
);
933 read_unlock(&GlobalSMBSeslock
);
934 } while(!signal_pending(current
));
935 complete_and_exit (&cifs_dnotify_exited
, 0);
942 #ifdef CONFIG_PROC_FS
945 INIT_LIST_HEAD(&GlobalServerList
); /* BB not implemented yet */
946 INIT_LIST_HEAD(&GlobalSMBSessionList
);
947 INIT_LIST_HEAD(&GlobalTreeConnectionList
);
948 INIT_LIST_HEAD(&GlobalOplock_Q
);
949 #ifdef CONFIG_CIFS_EXPERIMENTAL
950 INIT_LIST_HEAD(&GlobalDnotifyReqList
);
951 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q
);
954 * Initialize Global counters
956 atomic_set(&sesInfoAllocCount
, 0);
957 atomic_set(&tconInfoAllocCount
, 0);
958 atomic_set(&tcpSesAllocCount
,0);
959 atomic_set(&tcpSesReconnectCount
, 0);
960 atomic_set(&tconInfoReconnectCount
, 0);
962 atomic_set(&bufAllocCount
, 0);
963 atomic_set(&smBufAllocCount
, 0);
964 #ifdef CONFIG_CIFS_STATS2
965 atomic_set(&totBufAllocCount
, 0);
966 atomic_set(&totSmBufAllocCount
, 0);
967 #endif /* CONFIG_CIFS_STATS2 */
969 atomic_set(&midCount
, 0);
970 GlobalCurrentXid
= 0;
971 GlobalTotalActiveXid
= 0;
972 GlobalMaxActiveXid
= 0;
973 rwlock_init(&GlobalSMBSeslock
);
974 spin_lock_init(&GlobalMid_Lock
);
976 if(cifs_max_pending
< 2) {
977 cifs_max_pending
= 2;
978 cFYI(1,("cifs_max_pending set to min of 2"));
979 } else if(cifs_max_pending
> 256) {
980 cifs_max_pending
= 256;
981 cFYI(1,("cifs_max_pending set to max of 256"));
984 rc
= cifs_init_inodecache();
986 rc
= cifs_init_mids();
988 rc
= cifs_init_request_bufs();
990 rc
= register_filesystem(&cifs_fs_type
);
992 rc
= (int)kernel_thread(cifs_oplock_thread
, NULL
,
993 CLONE_FS
| CLONE_FILES
| CLONE_VM
);
995 rc
= (int)kernel_thread(cifs_dnotify_thread
, NULL
,
996 CLONE_FS
| CLONE_FILES
| CLONE_VM
);
1000 cERROR(1,("error %d create dnotify thread", rc
));
1002 cERROR(1,("error %d create oplock thread",rc
));
1005 cifs_destroy_request_bufs();
1007 cifs_destroy_mids();
1009 cifs_destroy_inodecache();
1011 #ifdef CONFIG_PROC_FS
1020 cFYI(0, ("In unregister ie exit_cifs"));
1021 #ifdef CONFIG_PROC_FS
1024 unregister_filesystem(&cifs_fs_type
);
1025 cifs_destroy_inodecache();
1026 cifs_destroy_mids();
1027 cifs_destroy_request_bufs();
1029 send_sig(SIGTERM
, oplockThread
, 1);
1030 wait_for_completion(&cifs_oplock_exited
);
1033 send_sig(SIGTERM
, dnotifyThread
, 1);
1034 wait_for_completion(&cifs_dnotify_exited
);
1038 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1039 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1041 ("VFS to access servers complying with the SNIA CIFS Specification e.g. Samba and Windows");
1042 MODULE_VERSION(CIFS_VERSION
);
1043 module_init(init_cifs
)
1044 module_exit(exit_cifs
)