4 * Copyright (C) International Business Machines Corp., 2002,2008
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>
36 #include <linux/kthread.h>
37 #include <linux/freezer.h>
41 #define DECLARE_GLOBALS_HERE
43 #include "cifsproto.h"
44 #include "cifs_debug.h"
45 #include "cifs_fs_sb.h"
47 #include <linux/key-type.h>
48 #include "cifs_spnego.h"
50 #define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
55 unsigned int oplockEnabled = 1;
56 unsigned int linuxExtEnabled = 1;
57 unsigned int lookupCacheEnabled = 1;
58 unsigned int multiuser_mount = 0;
59 unsigned int global_secflags = CIFSSEC_DEF;
60 /* unsigned int ntlmv2_support = 0; */
61 unsigned int sign_CIFS_PDUs = 1;
62 static const struct super_operations cifs_super_ops;
63 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
64 module_param(CIFSMaxBufSize, int, 0);
65 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
66 "Default: 16384 Range: 8192 to 130048");
67 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
68 module_param(cifs_min_rcv, int, 0);
69 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
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 "
75 unsigned int cifs_max_pending = CIFS_MAX_REQ;
76 module_param(cifs_max_pending, int, 0);
77 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
78 "Default: 50 Range: 2 to 256");
79 unsigned short echo_retries = 5;
80 module_param(echo_retries, ushort, 0644);
81 MODULE_PARM_DESC(echo_retries, "Number of echo attempts before giving up and "
82 "reconnecting server. Default: 5. 0 means "
84 extern mempool_t *cifs_sm_req_poolp;
85 extern mempool_t *cifs_req_poolp;
86 extern mempool_t *cifs_mid_poolp;
89 cifs_sb_active(struct super_block *sb)
91 struct cifs_sb_info *server = CIFS_SB(sb);
93 if (atomic_inc_return(&server->active) == 1)
94 atomic_inc(&sb->s_active);
98 cifs_sb_deactive(struct super_block *sb)
100 struct cifs_sb_info *server = CIFS_SB(sb);
102 if (atomic_dec_and_test(&server->active))
103 deactivate_super(sb);
107 cifs_read_super(struct super_block *sb)
110 struct cifs_sb_info *cifs_sb;
113 cifs_sb = CIFS_SB(sb);
115 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
116 sb->s_flags |= MS_POSIXACL;
118 if (cifs_sb_master_tcon(cifs_sb)->ses->capabilities & CAP_LARGE_FILES)
119 sb->s_maxbytes = MAX_LFS_FILESIZE;
121 sb->s_maxbytes = MAX_NON_LFS;
123 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
124 sb->s_time_gran = 100;
126 sb->s_magic = CIFS_MAGIC_NUMBER;
127 sb->s_op = &cifs_super_ops;
128 sb->s_bdi = &cifs_sb->bdi;
129 sb->s_blocksize = CIFS_MAX_MSGSIZE;
130 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
131 inode = cifs_root_iget(sb);
139 sb->s_root = d_alloc_root(inode);
146 /* do that *after* d_alloc_root() - we want NULL ->d_op for root here */
147 if (cifs_sb_master_tcon(cifs_sb)->nocase)
148 sb->s_d_op = &cifs_ci_dentry_ops;
150 sb->s_d_op = &cifs_dentry_ops;
152 #ifdef CIFS_NFSD_EXPORT
153 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
154 cFYI(1, "export ops supported");
155 sb->s_export_op = &cifs_export_ops;
157 #endif /* CIFS_NFSD_EXPORT */
162 cERROR(1, "cifs_read_super: get root inode failed");
169 static void cifs_kill_sb(struct super_block *sb)
171 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
173 cifs_umount(cifs_sb);
177 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
179 struct super_block *sb = dentry->d_sb;
180 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
181 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
182 int rc = -EOPNOTSUPP;
187 buf->f_type = CIFS_MAGIC_NUMBER;
190 * PATH_MAX may be too long - it would presumably be total path,
191 * but note that some servers (includinng Samba 3) have a shorter
194 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
196 buf->f_namelen = PATH_MAX;
197 buf->f_files = 0; /* undefined */
198 buf->f_ffree = 0; /* unlimited */
201 * We could add a second check for a QFS Unix capability bit
203 if ((tcon->ses->capabilities & CAP_UNIX) &&
204 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
205 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
208 * Only need to call the old QFSInfo if failed on newer one,
211 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
212 rc = CIFSSMBQFSInfo(xid, tcon, buf);
215 * Some old Windows servers also do not support level 103, retry with
216 * older level one if old server failed the previous call or we
217 * bypassed it because we detected that this was an older LANMAN sess
220 rc = SMBOldQFSInfo(xid, tcon, buf);
226 static int cifs_permission(struct inode *inode, int mask, unsigned int flags)
228 struct cifs_sb_info *cifs_sb;
230 cifs_sb = CIFS_SB(inode->i_sb);
232 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
233 if ((mask & MAY_EXEC) && !execute_ok(inode))
237 } else /* file mode might have been restricted at mount time
238 on the client (above and beyond ACL on servers) for
239 servers which do not support setting and viewing mode bits,
240 so allowing client to check permissions is useful */
241 return generic_permission(inode, mask, flags, NULL);
244 static struct kmem_cache *cifs_inode_cachep;
245 static struct kmem_cache *cifs_req_cachep;
246 static struct kmem_cache *cifs_mid_cachep;
247 static struct kmem_cache *cifs_sm_req_cachep;
248 mempool_t *cifs_sm_req_poolp;
249 mempool_t *cifs_req_poolp;
250 mempool_t *cifs_mid_poolp;
252 static struct inode *
253 cifs_alloc_inode(struct super_block *sb)
255 struct cifsInodeInfo *cifs_inode;
256 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
259 cifs_inode->cifsAttrs = 0x20; /* default */
260 cifs_inode->time = 0;
261 /* Until the file is open and we have gotten oplock
262 info back from the server, can not assume caching of
263 file data or metadata */
264 cifs_set_oplock_level(cifs_inode, 0);
265 cifs_inode->delete_pending = false;
266 cifs_inode->invalid_mapping = false;
267 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
268 cifs_inode->server_eof = 0;
269 cifs_inode->uniqueid = 0;
270 cifs_inode->createtime = 0;
272 /* Can not set i_flags here - they get immediately overwritten
273 to zero by the VFS */
274 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
275 INIT_LIST_HEAD(&cifs_inode->openFileList);
276 return &cifs_inode->vfs_inode;
279 static void cifs_i_callback(struct rcu_head *head)
281 struct inode *inode = container_of(head, struct inode, i_rcu);
282 INIT_LIST_HEAD(&inode->i_dentry);
283 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
287 cifs_destroy_inode(struct inode *inode)
289 call_rcu(&inode->i_rcu, cifs_i_callback);
293 cifs_evict_inode(struct inode *inode)
295 truncate_inode_pages(&inode->i_data, 0);
296 end_writeback(inode);
297 cifs_fscache_release_inode_cookie(inode);
301 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
303 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
304 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
306 seq_printf(s, ",addr=");
308 switch (server->dstaddr.ss_family) {
310 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
313 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
314 if (sa6->sin6_scope_id)
315 seq_printf(s, "%%%u", sa6->sin6_scope_id);
318 seq_printf(s, "(unknown)");
323 cifs_show_security(struct seq_file *s, struct TCP_Server_Info *server)
325 seq_printf(s, ",sec=");
327 switch (server->secType) {
329 seq_printf(s, "lanman");
332 seq_printf(s, "ntlmv2");
335 seq_printf(s, "ntlm");
338 seq_printf(s, "krb5");
341 seq_printf(s, "ntlmssp");
344 /* shouldn't ever happen */
345 seq_printf(s, "unknown");
349 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
354 * cifs_show_options() is for displaying mount options in /proc/mounts.
355 * Not all settable options are displayed but most of the important
359 cifs_show_options(struct seq_file *s, struct vfsmount *m)
361 struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
362 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
363 struct sockaddr *srcaddr;
364 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
366 cifs_show_security(s, tcon->ses->server);
368 seq_printf(s, ",unc=%s", tcon->treeName);
370 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
371 seq_printf(s, ",multiuser");
372 else if (tcon->ses->user_name)
373 seq_printf(s, ",username=%s", tcon->ses->user_name);
375 if (tcon->ses->domainName)
376 seq_printf(s, ",domain=%s", tcon->ses->domainName);
378 if (srcaddr->sa_family != AF_UNSPEC) {
379 struct sockaddr_in *saddr4;
380 struct sockaddr_in6 *saddr6;
381 saddr4 = (struct sockaddr_in *)srcaddr;
382 saddr6 = (struct sockaddr_in6 *)srcaddr;
383 if (srcaddr->sa_family == AF_INET6)
384 seq_printf(s, ",srcaddr=%pI6c",
386 else if (srcaddr->sa_family == AF_INET)
387 seq_printf(s, ",srcaddr=%pI4",
388 &saddr4->sin_addr.s_addr);
390 seq_printf(s, ",srcaddr=BAD-AF:%i",
391 (int)(srcaddr->sa_family));
394 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
395 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
396 seq_printf(s, ",forceuid");
398 seq_printf(s, ",noforceuid");
400 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
401 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
402 seq_printf(s, ",forcegid");
404 seq_printf(s, ",noforcegid");
406 cifs_show_address(s, tcon->ses->server);
409 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
410 cifs_sb->mnt_file_mode,
411 cifs_sb->mnt_dir_mode);
413 seq_printf(s, ",seal");
415 seq_printf(s, ",nocase");
417 seq_printf(s, ",hard");
419 seq_printf(s, ",unix");
421 seq_printf(s, ",nounix");
422 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
423 seq_printf(s, ",posixpaths");
424 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
425 seq_printf(s, ",setuids");
426 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
427 seq_printf(s, ",serverino");
428 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
429 seq_printf(s, ",rwpidforward");
430 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
431 seq_printf(s, ",forcemand");
432 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
433 seq_printf(s, ",directio");
434 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
435 seq_printf(s, ",nouser_xattr");
436 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
437 seq_printf(s, ",mapchars");
438 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
439 seq_printf(s, ",sfu");
440 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
441 seq_printf(s, ",nobrl");
442 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
443 seq_printf(s, ",cifsacl");
444 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
445 seq_printf(s, ",dynperm");
446 if (m->mnt_sb->s_flags & MS_POSIXACL)
447 seq_printf(s, ",acl");
448 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
449 seq_printf(s, ",mfsymlinks");
450 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
451 seq_printf(s, ",fsc");
453 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
454 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
455 /* convert actimeo and display it in seconds */
456 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
461 static void cifs_umount_begin(struct super_block *sb)
463 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
464 struct cifs_tcon *tcon;
469 tcon = cifs_sb_master_tcon(cifs_sb);
471 spin_lock(&cifs_tcp_ses_lock);
472 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
473 /* we have other mounts to same share or we have
474 already tried to force umount this and woken up
475 all waiting network requests, nothing to do */
476 spin_unlock(&cifs_tcp_ses_lock);
478 } else if (tcon->tc_count == 1)
479 tcon->tidStatus = CifsExiting;
480 spin_unlock(&cifs_tcp_ses_lock);
482 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
483 /* cancel_notify_requests(tcon); */
484 if (tcon->ses && tcon->ses->server) {
485 cFYI(1, "wake up tasks now - umount begin not complete");
486 wake_up_all(&tcon->ses->server->request_q);
487 wake_up_all(&tcon->ses->server->response_q);
488 msleep(1); /* yield */
489 /* we have to kick the requests once more */
490 wake_up_all(&tcon->ses->server->response_q);
497 #ifdef CONFIG_CIFS_STATS2
498 static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
505 static int cifs_remount(struct super_block *sb, int *flags, char *data)
507 *flags |= MS_NODIRATIME;
511 static int cifs_drop_inode(struct inode *inode)
513 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
515 /* no serverino => unconditional eviction */
516 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
517 generic_drop_inode(inode);
520 static const struct super_operations cifs_super_ops = {
521 .statfs = cifs_statfs,
522 .alloc_inode = cifs_alloc_inode,
523 .destroy_inode = cifs_destroy_inode,
524 .drop_inode = cifs_drop_inode,
525 .evict_inode = cifs_evict_inode,
526 /* .delete_inode = cifs_delete_inode, */ /* Do not need above
527 function unless later we add lazy close of inodes or unless the
528 kernel forgets to call us with the same number of releases (closes)
530 .show_options = cifs_show_options,
531 .umount_begin = cifs_umount_begin,
532 .remount_fs = cifs_remount,
533 #ifdef CONFIG_CIFS_STATS2
534 .show_stats = cifs_show_stats,
539 * Get root dentry from superblock according to prefix path mount option.
540 * Return dentry with refcount + 1 on success and NULL otherwise.
542 static struct dentry *
543 cifs_get_root(struct smb_vol *vol, struct super_block *sb)
548 struct dentry *dparent = NULL, *dchild = NULL, *alias;
549 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
550 unsigned int i, full_len, len;
551 char *full_path = NULL, *pstart;
554 full_path = cifs_build_path_to_root(vol, cifs_sb,
555 cifs_sb_master_tcon(cifs_sb));
556 if (full_path == NULL)
559 cFYI(1, "Get root dentry for %s", full_path);
562 sep = CIFS_DIR_SEP(cifs_sb);
563 dparent = dget(sb->s_root);
564 full_len = strlen(full_path);
565 full_path[full_len] = sep;
566 pstart = full_path + 1;
568 for (i = 1, len = 0; i <= full_len; i++) {
569 if (full_path[i] != sep || !len) {
575 cFYI(1, "get dentry for %s", pstart);
579 name.hash = full_name_hash(pstart, len);
580 dchild = d_lookup(dparent, &name);
581 if (dchild == NULL) {
582 cFYI(1, "not exists");
583 dchild = d_alloc(dparent, &name);
584 if (dchild == NULL) {
591 cFYI(1, "get inode");
592 if (dchild->d_inode == NULL) {
593 cFYI(1, "not exists");
595 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
596 rc = cifs_get_inode_info_unix(&inode, full_path,
599 rc = cifs_get_inode_info(&inode, full_path,
600 NULL, sb, xid, NULL);
607 alias = d_materialise_unique(dchild, inode);
618 cFYI(1, "parent %p, child %p", dparent, dchild);
623 pstart = full_path + i + 1;
632 static int cifs_set_super(struct super_block *sb, void *data)
634 struct cifs_mnt_data *mnt_data = data;
635 sb->s_fs_info = mnt_data->cifs_sb;
636 return set_anon_super(sb, NULL);
639 static struct dentry *
640 cifs_do_mount(struct file_system_type *fs_type,
641 int flags, const char *dev_name, void *data)
644 struct super_block *sb;
645 struct cifs_sb_info *cifs_sb;
646 struct smb_vol *volume_info;
647 struct cifs_mnt_data mnt_data;
650 cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
652 rc = cifs_setup_volume_info(&volume_info, (char *)data, dev_name);
656 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
657 if (cifs_sb == NULL) {
658 root = ERR_PTR(-ENOMEM);
659 unload_nls(volume_info->local_nls);
663 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
664 if (cifs_sb->mountdata == NULL) {
665 root = ERR_PTR(-ENOMEM);
666 unload_nls(volume_info->local_nls);
671 cifs_setup_cifs_sb(volume_info, cifs_sb);
673 rc = cifs_mount(cifs_sb, volume_info);
675 if (!(flags & MS_SILENT))
676 cERROR(1, "cifs_mount failed w/return code = %d", rc);
678 unload_nls(volume_info->local_nls);
679 kfree(cifs_sb->mountdata);
684 mnt_data.vol = volume_info;
685 mnt_data.cifs_sb = cifs_sb;
686 mnt_data.flags = flags;
688 sb = sget(fs_type, cifs_match_super, cifs_set_super, &mnt_data);
691 cifs_umount(cifs_sb);
696 cFYI(1, "Use existing superblock");
697 cifs_umount(cifs_sb);
702 /* BB should we make this contingent on mount parm? */
703 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
705 rc = cifs_read_super(sb);
711 sb->s_flags |= MS_ACTIVE;
713 root = cifs_get_root(volume_info, sb);
717 cFYI(1, "dentry root is: %p", root);
721 root = cifs_get_root(volume_info, sb);
723 cFYI(1, "dentry root is: %p", root);
727 deactivate_locked_super(sb);
729 cifs_cleanup_volume_info(&volume_info);
733 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
734 unsigned long nr_segs, loff_t pos)
736 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
740 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
742 if (CIFS_I(inode)->clientCanCacheAll)
745 rc = filemap_fdatawrite(inode->i_mapping);
747 cFYI(1, "cifs_file_aio_write: %d rc on %p inode", rc, inode);
752 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
754 /* origin == SEEK_END => we must revalidate the cached file length */
755 if (origin == SEEK_END) {
757 struct inode *inode = file->f_path.dentry->d_inode;
760 * We need to be sure that all dirty pages are written and the
761 * server has the newest file length.
763 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
764 inode->i_mapping->nrpages != 0) {
765 rc = filemap_fdatawait(inode->i_mapping);
767 mapping_set_error(inode->i_mapping, rc);
772 * Some applications poll for the file length in this strange
773 * way so we must seek to end on non-oplocked files by
774 * setting the revalidate time to zero.
776 CIFS_I(inode)->time = 0;
778 rc = cifs_revalidate_file_attr(file);
782 return generic_file_llseek_unlocked(file, offset, origin);
785 static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
787 /* note that this is called by vfs setlease with lock_flocks held
788 to protect *lease from going away */
789 struct inode *inode = file->f_path.dentry->d_inode;
790 struct cifsFileInfo *cfile = file->private_data;
792 if (!(S_ISREG(inode->i_mode)))
795 /* check if file is oplocked */
796 if (((arg == F_RDLCK) &&
797 (CIFS_I(inode)->clientCanCacheRead)) ||
799 (CIFS_I(inode)->clientCanCacheAll)))
800 return generic_setlease(file, arg, lease);
801 else if (tlink_tcon(cfile->tlink)->local_lease &&
802 !CIFS_I(inode)->clientCanCacheRead)
803 /* If the server claims to support oplock on this
804 file, then we still need to check oplock even
805 if the local_lease mount option is set, but there
806 are servers which do not support oplock for which
807 this mount option may be useful if the user
808 knows that the file won't be changed on the server
810 return generic_setlease(file, arg, lease);
815 struct file_system_type cifs_fs_type = {
816 .owner = THIS_MODULE,
818 .mount = cifs_do_mount,
819 .kill_sb = cifs_kill_sb,
822 const struct inode_operations cifs_dir_inode_ops = {
823 .create = cifs_create,
824 .lookup = cifs_lookup,
825 .getattr = cifs_getattr,
826 .unlink = cifs_unlink,
827 .link = cifs_hardlink,
830 .rename = cifs_rename,
831 .permission = cifs_permission,
832 /* revalidate:cifs_revalidate, */
833 .setattr = cifs_setattr,
834 .symlink = cifs_symlink,
836 #ifdef CONFIG_CIFS_XATTR
837 .setxattr = cifs_setxattr,
838 .getxattr = cifs_getxattr,
839 .listxattr = cifs_listxattr,
840 .removexattr = cifs_removexattr,
844 const struct inode_operations cifs_file_inode_ops = {
845 /* revalidate:cifs_revalidate, */
846 .setattr = cifs_setattr,
847 .getattr = cifs_getattr, /* do we need this anymore? */
848 .rename = cifs_rename,
849 .permission = cifs_permission,
850 #ifdef CONFIG_CIFS_XATTR
851 .setxattr = cifs_setxattr,
852 .getxattr = cifs_getxattr,
853 .listxattr = cifs_listxattr,
854 .removexattr = cifs_removexattr,
858 const struct inode_operations cifs_symlink_inode_ops = {
859 .readlink = generic_readlink,
860 .follow_link = cifs_follow_link,
861 .put_link = cifs_put_link,
862 .permission = cifs_permission,
863 /* BB add the following two eventually */
864 /* revalidate: cifs_revalidate,
865 setattr: cifs_notify_change, *//* BB do we need notify change */
866 #ifdef CONFIG_CIFS_XATTR
867 .setxattr = cifs_setxattr,
868 .getxattr = cifs_getxattr,
869 .listxattr = cifs_listxattr,
870 .removexattr = cifs_removexattr,
874 const struct file_operations cifs_file_ops = {
875 .read = do_sync_read,
876 .write = do_sync_write,
877 .aio_read = generic_file_aio_read,
878 .aio_write = cifs_file_aio_write,
880 .release = cifs_close,
884 .mmap = cifs_file_mmap,
885 .splice_read = generic_file_splice_read,
886 .llseek = cifs_llseek,
887 #ifdef CONFIG_CIFS_POSIX
888 .unlocked_ioctl = cifs_ioctl,
889 #endif /* CONFIG_CIFS_POSIX */
890 .setlease = cifs_setlease,
893 const struct file_operations cifs_file_strict_ops = {
894 .read = do_sync_read,
895 .write = do_sync_write,
896 .aio_read = cifs_strict_readv,
897 .aio_write = cifs_strict_writev,
899 .release = cifs_close,
901 .fsync = cifs_strict_fsync,
903 .mmap = cifs_file_strict_mmap,
904 .splice_read = generic_file_splice_read,
905 .llseek = cifs_llseek,
906 #ifdef CONFIG_CIFS_POSIX
907 .unlocked_ioctl = cifs_ioctl,
908 #endif /* CONFIG_CIFS_POSIX */
909 .setlease = cifs_setlease,
912 const struct file_operations cifs_file_direct_ops = {
913 /* BB reevaluate whether they can be done with directio, no cache */
914 .read = do_sync_read,
915 .write = do_sync_write,
916 .aio_read = cifs_user_readv,
917 .aio_write = cifs_user_writev,
919 .release = cifs_close,
923 .mmap = cifs_file_mmap,
924 .splice_read = generic_file_splice_read,
925 #ifdef CONFIG_CIFS_POSIX
926 .unlocked_ioctl = cifs_ioctl,
927 #endif /* CONFIG_CIFS_POSIX */
928 .llseek = cifs_llseek,
929 .setlease = cifs_setlease,
932 const struct file_operations cifs_file_nobrl_ops = {
933 .read = do_sync_read,
934 .write = do_sync_write,
935 .aio_read = generic_file_aio_read,
936 .aio_write = cifs_file_aio_write,
938 .release = cifs_close,
941 .mmap = cifs_file_mmap,
942 .splice_read = generic_file_splice_read,
943 .llseek = cifs_llseek,
944 #ifdef CONFIG_CIFS_POSIX
945 .unlocked_ioctl = cifs_ioctl,
946 #endif /* CONFIG_CIFS_POSIX */
947 .setlease = cifs_setlease,
950 const struct file_operations cifs_file_strict_nobrl_ops = {
951 .read = do_sync_read,
952 .write = do_sync_write,
953 .aio_read = cifs_strict_readv,
954 .aio_write = cifs_strict_writev,
956 .release = cifs_close,
957 .fsync = cifs_strict_fsync,
959 .mmap = cifs_file_strict_mmap,
960 .splice_read = generic_file_splice_read,
961 .llseek = cifs_llseek,
962 #ifdef CONFIG_CIFS_POSIX
963 .unlocked_ioctl = cifs_ioctl,
964 #endif /* CONFIG_CIFS_POSIX */
965 .setlease = cifs_setlease,
968 const struct file_operations cifs_file_direct_nobrl_ops = {
969 /* BB reevaluate whether they can be done with directio, no cache */
970 .read = do_sync_read,
971 .write = do_sync_write,
972 .aio_read = cifs_user_readv,
973 .aio_write = cifs_user_writev,
975 .release = cifs_close,
978 .mmap = cifs_file_mmap,
979 .splice_read = generic_file_splice_read,
980 #ifdef CONFIG_CIFS_POSIX
981 .unlocked_ioctl = cifs_ioctl,
982 #endif /* CONFIG_CIFS_POSIX */
983 .llseek = cifs_llseek,
984 .setlease = cifs_setlease,
987 const struct file_operations cifs_dir_ops = {
988 .readdir = cifs_readdir,
989 .release = cifs_closedir,
990 .read = generic_read_dir,
991 .unlocked_ioctl = cifs_ioctl,
992 .llseek = generic_file_llseek,
996 cifs_init_once(void *inode)
998 struct cifsInodeInfo *cifsi = inode;
1000 inode_init_once(&cifsi->vfs_inode);
1001 INIT_LIST_HEAD(&cifsi->lockList);
1005 cifs_init_inodecache(void)
1007 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1008 sizeof(struct cifsInodeInfo),
1009 0, (SLAB_RECLAIM_ACCOUNT|
1012 if (cifs_inode_cachep == NULL)
1019 cifs_destroy_inodecache(void)
1021 kmem_cache_destroy(cifs_inode_cachep);
1025 cifs_init_request_bufs(void)
1027 if (CIFSMaxBufSize < 8192) {
1028 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1029 Unicode path name has to fit in any SMB/CIFS path based frames */
1030 CIFSMaxBufSize = 8192;
1031 } else if (CIFSMaxBufSize > 1024*127) {
1032 CIFSMaxBufSize = 1024 * 127;
1034 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1036 /* cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
1037 cifs_req_cachep = kmem_cache_create("cifs_request",
1039 MAX_CIFS_HDR_SIZE, 0,
1040 SLAB_HWCACHE_ALIGN, NULL);
1041 if (cifs_req_cachep == NULL)
1044 if (cifs_min_rcv < 1)
1046 else if (cifs_min_rcv > 64) {
1048 cERROR(1, "cifs_min_rcv set to maximum (64)");
1051 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1054 if (cifs_req_poolp == NULL) {
1055 kmem_cache_destroy(cifs_req_cachep);
1058 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1059 almost all handle based requests (but not write response, nor is it
1060 sufficient for path based requests). A smaller size would have
1061 been more efficient (compacting multiple slab items on one 4k page)
1062 for the case in which debug was on, but this larger size allows
1063 more SMBs to use small buffer alloc and is still much more
1064 efficient to alloc 1 per page off the slab compared to 17K (5page)
1065 alloc of large cifs buffers even when page debugging is on */
1066 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
1067 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1069 if (cifs_sm_req_cachep == NULL) {
1070 mempool_destroy(cifs_req_poolp);
1071 kmem_cache_destroy(cifs_req_cachep);
1075 if (cifs_min_small < 2)
1077 else if (cifs_min_small > 256) {
1078 cifs_min_small = 256;
1079 cFYI(1, "cifs_min_small set to maximum (256)");
1082 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1083 cifs_sm_req_cachep);
1085 if (cifs_sm_req_poolp == NULL) {
1086 mempool_destroy(cifs_req_poolp);
1087 kmem_cache_destroy(cifs_req_cachep);
1088 kmem_cache_destroy(cifs_sm_req_cachep);
1096 cifs_destroy_request_bufs(void)
1098 mempool_destroy(cifs_req_poolp);
1099 kmem_cache_destroy(cifs_req_cachep);
1100 mempool_destroy(cifs_sm_req_poolp);
1101 kmem_cache_destroy(cifs_sm_req_cachep);
1105 cifs_init_mids(void)
1107 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1108 sizeof(struct mid_q_entry), 0,
1109 SLAB_HWCACHE_ALIGN, NULL);
1110 if (cifs_mid_cachep == NULL)
1113 /* 3 is a reasonable minimum number of simultaneous operations */
1114 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1115 if (cifs_mid_poolp == NULL) {
1116 kmem_cache_destroy(cifs_mid_cachep);
1124 cifs_destroy_mids(void)
1126 mempool_destroy(cifs_mid_poolp);
1127 kmem_cache_destroy(cifs_mid_cachep);
1135 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1136 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1137 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1138 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1139 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1141 * Initialize Global counters
1143 atomic_set(&sesInfoAllocCount, 0);
1144 atomic_set(&tconInfoAllocCount, 0);
1145 atomic_set(&tcpSesAllocCount, 0);
1146 atomic_set(&tcpSesReconnectCount, 0);
1147 atomic_set(&tconInfoReconnectCount, 0);
1149 atomic_set(&bufAllocCount, 0);
1150 atomic_set(&smBufAllocCount, 0);
1151 #ifdef CONFIG_CIFS_STATS2
1152 atomic_set(&totBufAllocCount, 0);
1153 atomic_set(&totSmBufAllocCount, 0);
1154 #endif /* CONFIG_CIFS_STATS2 */
1156 atomic_set(&midCount, 0);
1157 GlobalCurrentXid = 0;
1158 GlobalTotalActiveXid = 0;
1159 GlobalMaxActiveXid = 0;
1160 spin_lock_init(&cifs_tcp_ses_lock);
1161 spin_lock_init(&cifs_file_list_lock);
1162 spin_lock_init(&GlobalMid_Lock);
1164 if (cifs_max_pending < 2) {
1165 cifs_max_pending = 2;
1166 cFYI(1, "cifs_max_pending set to min of 2");
1167 } else if (cifs_max_pending > 256) {
1168 cifs_max_pending = 256;
1169 cFYI(1, "cifs_max_pending set to max of 256");
1172 rc = cifs_fscache_register();
1174 goto out_clean_proc;
1176 rc = cifs_init_inodecache();
1178 goto out_unreg_fscache;
1180 rc = cifs_init_mids();
1182 goto out_destroy_inodecache;
1184 rc = cifs_init_request_bufs();
1186 goto out_destroy_mids;
1188 #ifdef CONFIG_CIFS_UPCALL
1189 rc = register_key_type(&cifs_spnego_key_type);
1191 goto out_destroy_request_bufs;
1192 #endif /* CONFIG_CIFS_UPCALL */
1194 #ifdef CONFIG_CIFS_ACL
1195 rc = init_cifs_idmap();
1197 goto out_register_key_type;
1198 #endif /* CONFIG_CIFS_ACL */
1200 rc = register_filesystem(&cifs_fs_type);
1202 goto out_init_cifs_idmap;
1206 out_init_cifs_idmap:
1207 #ifdef CONFIG_CIFS_ACL
1209 out_register_key_type:
1211 #ifdef CONFIG_CIFS_UPCALL
1212 unregister_key_type(&cifs_spnego_key_type);
1213 out_destroy_request_bufs:
1215 cifs_destroy_request_bufs();
1217 cifs_destroy_mids();
1218 out_destroy_inodecache:
1219 cifs_destroy_inodecache();
1221 cifs_fscache_unregister();
1230 cFYI(DBG2, "exit_cifs");
1232 cifs_fscache_unregister();
1233 #ifdef CONFIG_CIFS_DFS_UPCALL
1234 cifs_dfs_release_automount_timer();
1236 #ifdef CONFIG_CIFS_ACL
1237 cifs_destroy_idmaptrees();
1240 #ifdef CONFIG_CIFS_UPCALL
1241 unregister_key_type(&cifs_spnego_key_type);
1243 unregister_filesystem(&cifs_fs_type);
1244 cifs_destroy_inodecache();
1245 cifs_destroy_mids();
1246 cifs_destroy_request_bufs();
1249 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1250 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1252 ("VFS to access servers complying with the SNIA CIFS Specification "
1253 "e.g. Samba and Windows");
1254 MODULE_VERSION(CIFS_VERSION);
1255 module_init(init_cifs)
1256 module_exit(exit_cifs)