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>
38 #include <linux/namei.h>
42 #define DECLARE_GLOBALS_HERE
44 #include "cifsproto.h"
45 #include "cifs_debug.h"
46 #include "cifs_fs_sb.h"
48 #include <linux/key-type.h>
49 #include "cifs_spnego.h"
51 #define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
56 bool enable_oplocks = true;
57 unsigned int linuxExtEnabled = 1;
58 unsigned int lookupCacheEnabled = 1;
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, 0444);
77 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
78 "Default: 32767 Range: 2 to 32767.");
79 module_param(enable_oplocks, bool, 0644);
80 MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks (bool). Default:"
83 extern mempool_t *cifs_sm_req_poolp;
84 extern mempool_t *cifs_req_poolp;
85 extern mempool_t *cifs_mid_poolp;
87 struct workqueue_struct *cifsiod_wq;
90 cifs_read_super(struct super_block *sb)
93 struct cifs_sb_info *cifs_sb;
96 cifs_sb = CIFS_SB(sb);
98 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
99 sb->s_flags |= MS_POSIXACL;
101 if (cifs_sb_master_tcon(cifs_sb)->ses->capabilities & CAP_LARGE_FILES)
102 sb->s_maxbytes = MAX_LFS_FILESIZE;
104 sb->s_maxbytes = MAX_NON_LFS;
106 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
107 sb->s_time_gran = 100;
109 sb->s_magic = CIFS_MAGIC_NUMBER;
110 sb->s_op = &cifs_super_ops;
111 sb->s_bdi = &cifs_sb->bdi;
112 sb->s_blocksize = CIFS_MAX_MSGSIZE;
113 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
114 inode = cifs_root_iget(sb);
121 sb->s_root = d_make_root(inode);
127 /* do that *after* d_make_root() - we want NULL ->d_op for root here */
128 if (cifs_sb_master_tcon(cifs_sb)->nocase)
129 sb->s_d_op = &cifs_ci_dentry_ops;
131 sb->s_d_op = &cifs_dentry_ops;
133 #ifdef CONFIG_CIFS_NFSD_EXPORT
134 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
135 cFYI(1, "export ops supported");
136 sb->s_export_op = &cifs_export_ops;
138 #endif /* CONFIG_CIFS_NFSD_EXPORT */
143 cERROR(1, "cifs_read_super: get root inode failed");
147 static void cifs_kill_sb(struct super_block *sb)
149 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
151 cifs_umount(cifs_sb);
155 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
157 struct super_block *sb = dentry->d_sb;
158 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
159 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
160 int rc = -EOPNOTSUPP;
165 buf->f_type = CIFS_MAGIC_NUMBER;
168 * PATH_MAX may be too long - it would presumably be total path,
169 * but note that some servers (includinng Samba 3) have a shorter
172 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
174 buf->f_namelen = PATH_MAX;
175 buf->f_files = 0; /* undefined */
176 buf->f_ffree = 0; /* unlimited */
179 * We could add a second check for a QFS Unix capability bit
181 if ((tcon->ses->capabilities & CAP_UNIX) &&
182 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
183 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
186 * Only need to call the old QFSInfo if failed on newer one,
189 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
190 rc = CIFSSMBQFSInfo(xid, tcon, buf);
193 * Some old Windows servers also do not support level 103, retry with
194 * older level one if old server failed the previous call or we
195 * bypassed it because we detected that this was an older LANMAN sess
198 rc = SMBOldQFSInfo(xid, tcon, buf);
204 static int cifs_permission(struct inode *inode, int mask)
206 struct cifs_sb_info *cifs_sb;
208 cifs_sb = CIFS_SB(inode->i_sb);
210 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
211 if ((mask & MAY_EXEC) && !execute_ok(inode))
215 } else /* file mode might have been restricted at mount time
216 on the client (above and beyond ACL on servers) for
217 servers which do not support setting and viewing mode bits,
218 so allowing client to check permissions is useful */
219 return generic_permission(inode, mask);
222 static struct kmem_cache *cifs_inode_cachep;
223 static struct kmem_cache *cifs_req_cachep;
224 static struct kmem_cache *cifs_mid_cachep;
225 static struct kmem_cache *cifs_sm_req_cachep;
226 mempool_t *cifs_sm_req_poolp;
227 mempool_t *cifs_req_poolp;
228 mempool_t *cifs_mid_poolp;
230 static struct inode *
231 cifs_alloc_inode(struct super_block *sb)
233 struct cifsInodeInfo *cifs_inode;
234 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
237 cifs_inode->cifsAttrs = 0x20; /* default */
238 cifs_inode->time = 0;
239 /* Until the file is open and we have gotten oplock
240 info back from the server, can not assume caching of
241 file data or metadata */
242 cifs_set_oplock_level(cifs_inode, 0);
243 cifs_inode->delete_pending = false;
244 cifs_inode->invalid_mapping = false;
245 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
246 cifs_inode->server_eof = 0;
247 cifs_inode->uniqueid = 0;
248 cifs_inode->createtime = 0;
250 /* Can not set i_flags here - they get immediately overwritten
251 to zero by the VFS */
252 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
253 INIT_LIST_HEAD(&cifs_inode->openFileList);
254 return &cifs_inode->vfs_inode;
257 static void cifs_i_callback(struct rcu_head *head)
259 struct inode *inode = container_of(head, struct inode, i_rcu);
260 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
264 cifs_destroy_inode(struct inode *inode)
266 call_rcu(&inode->i_rcu, cifs_i_callback);
270 cifs_evict_inode(struct inode *inode)
272 truncate_inode_pages(&inode->i_data, 0);
274 cifs_fscache_release_inode_cookie(inode);
278 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
280 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
281 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
283 seq_printf(s, ",addr=");
285 switch (server->dstaddr.ss_family) {
287 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
290 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
291 if (sa6->sin6_scope_id)
292 seq_printf(s, "%%%u", sa6->sin6_scope_id);
295 seq_printf(s, "(unknown)");
300 cifs_show_security(struct seq_file *s, struct TCP_Server_Info *server)
302 seq_printf(s, ",sec=");
304 switch (server->secType) {
306 seq_printf(s, "lanman");
309 seq_printf(s, "ntlmv2");
312 seq_printf(s, "ntlm");
315 seq_printf(s, "krb5");
318 seq_printf(s, "ntlmssp");
321 /* shouldn't ever happen */
322 seq_printf(s, "unknown");
326 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
331 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
333 seq_printf(s, ",cache=");
335 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
336 seq_printf(s, "strict");
337 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
338 seq_printf(s, "none");
340 seq_printf(s, "loose");
344 * cifs_show_options() is for displaying mount options in /proc/mounts.
345 * Not all settable options are displayed but most of the important
349 cifs_show_options(struct seq_file *s, struct dentry *root)
351 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
352 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
353 struct sockaddr *srcaddr;
354 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
356 seq_printf(s, ",vers=%s", tcon->ses->server->vals->version_string);
357 cifs_show_security(s, tcon->ses->server);
358 cifs_show_cache_flavor(s, cifs_sb);
360 seq_printf(s, ",unc=%s", tcon->treeName);
362 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
363 seq_printf(s, ",multiuser");
364 else if (tcon->ses->user_name)
365 seq_printf(s, ",username=%s", tcon->ses->user_name);
367 if (tcon->ses->domainName)
368 seq_printf(s, ",domain=%s", tcon->ses->domainName);
370 if (srcaddr->sa_family != AF_UNSPEC) {
371 struct sockaddr_in *saddr4;
372 struct sockaddr_in6 *saddr6;
373 saddr4 = (struct sockaddr_in *)srcaddr;
374 saddr6 = (struct sockaddr_in6 *)srcaddr;
375 if (srcaddr->sa_family == AF_INET6)
376 seq_printf(s, ",srcaddr=%pI6c",
378 else if (srcaddr->sa_family == AF_INET)
379 seq_printf(s, ",srcaddr=%pI4",
380 &saddr4->sin_addr.s_addr);
382 seq_printf(s, ",srcaddr=BAD-AF:%i",
383 (int)(srcaddr->sa_family));
386 seq_printf(s, ",uid=%u", cifs_sb->mnt_uid);
387 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
388 seq_printf(s, ",forceuid");
390 seq_printf(s, ",noforceuid");
392 seq_printf(s, ",gid=%u", cifs_sb->mnt_gid);
393 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
394 seq_printf(s, ",forcegid");
396 seq_printf(s, ",noforcegid");
398 cifs_show_address(s, tcon->ses->server);
401 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
402 cifs_sb->mnt_file_mode,
403 cifs_sb->mnt_dir_mode);
405 seq_printf(s, ",seal");
407 seq_printf(s, ",nocase");
409 seq_printf(s, ",hard");
411 seq_printf(s, ",unix");
413 seq_printf(s, ",nounix");
414 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
415 seq_printf(s, ",posixpaths");
416 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
417 seq_printf(s, ",setuids");
418 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
419 seq_printf(s, ",serverino");
420 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
421 seq_printf(s, ",rwpidforward");
422 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
423 seq_printf(s, ",forcemand");
424 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
425 seq_printf(s, ",nouser_xattr");
426 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
427 seq_printf(s, ",mapchars");
428 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
429 seq_printf(s, ",sfu");
430 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
431 seq_printf(s, ",nobrl");
432 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
433 seq_printf(s, ",cifsacl");
434 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
435 seq_printf(s, ",dynperm");
436 if (root->d_sb->s_flags & MS_POSIXACL)
437 seq_printf(s, ",acl");
438 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
439 seq_printf(s, ",mfsymlinks");
440 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
441 seq_printf(s, ",fsc");
442 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
443 seq_printf(s, ",nostrictsync");
444 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
445 seq_printf(s, ",noperm");
446 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
447 seq_printf(s, ",backupuid=%u", cifs_sb->mnt_backupuid);
448 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
449 seq_printf(s, ",backupgid=%u", cifs_sb->mnt_backupgid);
451 seq_printf(s, ",rsize=%u", cifs_sb->rsize);
452 seq_printf(s, ",wsize=%u", cifs_sb->wsize);
453 /* convert actimeo and display it in seconds */
454 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
459 static void cifs_umount_begin(struct super_block *sb)
461 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
462 struct cifs_tcon *tcon;
467 tcon = cifs_sb_master_tcon(cifs_sb);
469 spin_lock(&cifs_tcp_ses_lock);
470 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
471 /* we have other mounts to same share or we have
472 already tried to force umount this and woken up
473 all waiting network requests, nothing to do */
474 spin_unlock(&cifs_tcp_ses_lock);
476 } else if (tcon->tc_count == 1)
477 tcon->tidStatus = CifsExiting;
478 spin_unlock(&cifs_tcp_ses_lock);
480 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
481 /* cancel_notify_requests(tcon); */
482 if (tcon->ses && tcon->ses->server) {
483 cFYI(1, "wake up tasks now - umount begin not complete");
484 wake_up_all(&tcon->ses->server->request_q);
485 wake_up_all(&tcon->ses->server->response_q);
486 msleep(1); /* yield */
487 /* we have to kick the requests once more */
488 wake_up_all(&tcon->ses->server->response_q);
495 #ifdef CONFIG_CIFS_STATS2
496 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
503 static int cifs_remount(struct super_block *sb, int *flags, char *data)
505 *flags |= MS_NODIRATIME;
509 static int cifs_drop_inode(struct inode *inode)
511 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
513 /* no serverino => unconditional eviction */
514 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
515 generic_drop_inode(inode);
518 static const struct super_operations cifs_super_ops = {
519 .statfs = cifs_statfs,
520 .alloc_inode = cifs_alloc_inode,
521 .destroy_inode = cifs_destroy_inode,
522 .drop_inode = cifs_drop_inode,
523 .evict_inode = cifs_evict_inode,
524 /* .delete_inode = cifs_delete_inode, */ /* Do not need above
525 function unless later we add lazy close of inodes or unless the
526 kernel forgets to call us with the same number of releases (closes)
528 .show_options = cifs_show_options,
529 .umount_begin = cifs_umount_begin,
530 .remount_fs = cifs_remount,
531 #ifdef CONFIG_CIFS_STATS2
532 .show_stats = cifs_show_stats,
537 * Get root dentry from superblock according to prefix path mount option.
538 * Return dentry with refcount + 1 on success and NULL otherwise.
540 static struct dentry *
541 cifs_get_root(struct smb_vol *vol, struct super_block *sb)
543 struct dentry *dentry;
544 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
545 char *full_path = NULL;
549 full_path = cifs_build_path_to_root(vol, cifs_sb,
550 cifs_sb_master_tcon(cifs_sb));
551 if (full_path == NULL)
552 return ERR_PTR(-ENOMEM);
554 cFYI(1, "Get root dentry for %s", full_path);
556 sep = CIFS_DIR_SEP(cifs_sb);
557 dentry = dget(sb->s_root);
561 struct inode *dir = dentry->d_inode;
562 struct dentry *child;
566 dentry = ERR_PTR(-ENOENT);
570 /* skip separators */
577 while (*s && *s != sep)
580 mutex_lock(&dir->i_mutex);
581 child = lookup_one_len(p, dentry, s - p);
582 mutex_unlock(&dir->i_mutex);
585 } while (!IS_ERR(dentry));
590 static int cifs_set_super(struct super_block *sb, void *data)
592 struct cifs_mnt_data *mnt_data = data;
593 sb->s_fs_info = mnt_data->cifs_sb;
594 return set_anon_super(sb, NULL);
597 static struct dentry *
598 cifs_do_mount(struct file_system_type *fs_type,
599 int flags, const char *dev_name, void *data)
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;
608 cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
610 volume_info = cifs_get_volume_info((char *)data, dev_name);
611 if (IS_ERR(volume_info))
612 return ERR_CAST(volume_info);
614 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
615 if (cifs_sb == NULL) {
616 root = ERR_PTR(-ENOMEM);
620 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
621 if (cifs_sb->mountdata == NULL) {
622 root = ERR_PTR(-ENOMEM);
626 cifs_setup_cifs_sb(volume_info, cifs_sb);
628 rc = cifs_mount(cifs_sb, volume_info);
630 if (!(flags & MS_SILENT))
631 cERROR(1, "cifs_mount failed w/return code = %d", rc);
636 mnt_data.vol = volume_info;
637 mnt_data.cifs_sb = cifs_sb;
638 mnt_data.flags = flags;
640 /* BB should we make this contingent on mount parm? */
641 flags |= MS_NODIRATIME | MS_NOATIME;
643 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
646 cifs_umount(cifs_sb);
651 cFYI(1, "Use existing superblock");
652 cifs_umount(cifs_sb);
654 rc = cifs_read_super(sb);
660 sb->s_flags |= MS_ACTIVE;
663 root = cifs_get_root(volume_info, sb);
667 cFYI(1, "dentry root is: %p", root);
671 deactivate_locked_super(sb);
673 cifs_cleanup_volume_info(volume_info);
677 kfree(cifs_sb->mountdata);
681 unload_nls(volume_info->local_nls);
685 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
686 unsigned long nr_segs, loff_t pos)
688 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
692 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
694 if (CIFS_I(inode)->clientCanCacheAll)
697 rc = filemap_fdatawrite(inode->i_mapping);
699 cFYI(1, "cifs_file_aio_write: %d rc on %p inode", rc, inode);
704 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
707 * origin == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
708 * the cached file length
710 if (origin != SEEK_SET && origin != SEEK_CUR) {
712 struct inode *inode = file->f_path.dentry->d_inode;
715 * We need to be sure that all dirty pages are written and the
716 * server has the newest file length.
718 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
719 inode->i_mapping->nrpages != 0) {
720 rc = filemap_fdatawait(inode->i_mapping);
722 mapping_set_error(inode->i_mapping, rc);
727 * Some applications poll for the file length in this strange
728 * way so we must seek to end on non-oplocked files by
729 * setting the revalidate time to zero.
731 CIFS_I(inode)->time = 0;
733 rc = cifs_revalidate_file_attr(file);
737 return generic_file_llseek(file, offset, origin);
740 static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
742 /* note that this is called by vfs setlease with lock_flocks held
743 to protect *lease from going away */
744 struct inode *inode = file->f_path.dentry->d_inode;
745 struct cifsFileInfo *cfile = file->private_data;
747 if (!(S_ISREG(inode->i_mode)))
750 /* check if file is oplocked */
751 if (((arg == F_RDLCK) &&
752 (CIFS_I(inode)->clientCanCacheRead)) ||
754 (CIFS_I(inode)->clientCanCacheAll)))
755 return generic_setlease(file, arg, lease);
756 else if (tlink_tcon(cfile->tlink)->local_lease &&
757 !CIFS_I(inode)->clientCanCacheRead)
758 /* If the server claims to support oplock on this
759 file, then we still need to check oplock even
760 if the local_lease mount option is set, but there
761 are servers which do not support oplock for which
762 this mount option may be useful if the user
763 knows that the file won't be changed on the server
765 return generic_setlease(file, arg, lease);
770 struct file_system_type cifs_fs_type = {
771 .owner = THIS_MODULE,
773 .mount = cifs_do_mount,
774 .kill_sb = cifs_kill_sb,
777 const struct inode_operations cifs_dir_inode_ops = {
778 .create = cifs_create,
779 .atomic_open = cifs_atomic_open,
780 .lookup = cifs_lookup,
781 .getattr = cifs_getattr,
782 .unlink = cifs_unlink,
783 .link = cifs_hardlink,
786 .rename = cifs_rename,
787 .permission = cifs_permission,
788 /* revalidate:cifs_revalidate, */
789 .setattr = cifs_setattr,
790 .symlink = cifs_symlink,
792 #ifdef CONFIG_CIFS_XATTR
793 .setxattr = cifs_setxattr,
794 .getxattr = cifs_getxattr,
795 .listxattr = cifs_listxattr,
796 .removexattr = cifs_removexattr,
800 const struct inode_operations cifs_file_inode_ops = {
801 /* revalidate:cifs_revalidate, */
802 .setattr = cifs_setattr,
803 .getattr = cifs_getattr, /* do we need this anymore? */
804 .rename = cifs_rename,
805 .permission = cifs_permission,
806 #ifdef CONFIG_CIFS_XATTR
807 .setxattr = cifs_setxattr,
808 .getxattr = cifs_getxattr,
809 .listxattr = cifs_listxattr,
810 .removexattr = cifs_removexattr,
814 const struct inode_operations cifs_symlink_inode_ops = {
815 .readlink = generic_readlink,
816 .follow_link = cifs_follow_link,
817 .put_link = cifs_put_link,
818 .permission = cifs_permission,
819 /* BB add the following two eventually */
820 /* revalidate: cifs_revalidate,
821 setattr: cifs_notify_change, *//* BB do we need notify change */
822 #ifdef CONFIG_CIFS_XATTR
823 .setxattr = cifs_setxattr,
824 .getxattr = cifs_getxattr,
825 .listxattr = cifs_listxattr,
826 .removexattr = cifs_removexattr,
830 const struct file_operations cifs_file_ops = {
831 .read = do_sync_read,
832 .write = do_sync_write,
833 .aio_read = generic_file_aio_read,
834 .aio_write = cifs_file_aio_write,
836 .release = cifs_close,
840 .mmap = cifs_file_mmap,
841 .splice_read = generic_file_splice_read,
842 .llseek = cifs_llseek,
843 #ifdef CONFIG_CIFS_POSIX
844 .unlocked_ioctl = cifs_ioctl,
845 #endif /* CONFIG_CIFS_POSIX */
846 .setlease = cifs_setlease,
849 const struct file_operations cifs_file_strict_ops = {
850 .read = do_sync_read,
851 .write = do_sync_write,
852 .aio_read = cifs_strict_readv,
853 .aio_write = cifs_strict_writev,
855 .release = cifs_close,
857 .fsync = cifs_strict_fsync,
859 .mmap = cifs_file_strict_mmap,
860 .splice_read = generic_file_splice_read,
861 .llseek = cifs_llseek,
862 #ifdef CONFIG_CIFS_POSIX
863 .unlocked_ioctl = cifs_ioctl,
864 #endif /* CONFIG_CIFS_POSIX */
865 .setlease = cifs_setlease,
868 const struct file_operations cifs_file_direct_ops = {
869 /* BB reevaluate whether they can be done with directio, no cache */
870 .read = do_sync_read,
871 .write = do_sync_write,
872 .aio_read = cifs_user_readv,
873 .aio_write = cifs_user_writev,
875 .release = cifs_close,
879 .mmap = cifs_file_mmap,
880 .splice_read = generic_file_splice_read,
881 #ifdef CONFIG_CIFS_POSIX
882 .unlocked_ioctl = cifs_ioctl,
883 #endif /* CONFIG_CIFS_POSIX */
884 .llseek = cifs_llseek,
885 .setlease = cifs_setlease,
888 const struct file_operations cifs_file_nobrl_ops = {
889 .read = do_sync_read,
890 .write = do_sync_write,
891 .aio_read = generic_file_aio_read,
892 .aio_write = cifs_file_aio_write,
894 .release = cifs_close,
897 .mmap = cifs_file_mmap,
898 .splice_read = generic_file_splice_read,
899 .llseek = cifs_llseek,
900 #ifdef CONFIG_CIFS_POSIX
901 .unlocked_ioctl = cifs_ioctl,
902 #endif /* CONFIG_CIFS_POSIX */
903 .setlease = cifs_setlease,
906 const struct file_operations cifs_file_strict_nobrl_ops = {
907 .read = do_sync_read,
908 .write = do_sync_write,
909 .aio_read = cifs_strict_readv,
910 .aio_write = cifs_strict_writev,
912 .release = cifs_close,
913 .fsync = cifs_strict_fsync,
915 .mmap = cifs_file_strict_mmap,
916 .splice_read = generic_file_splice_read,
917 .llseek = cifs_llseek,
918 #ifdef CONFIG_CIFS_POSIX
919 .unlocked_ioctl = cifs_ioctl,
920 #endif /* CONFIG_CIFS_POSIX */
921 .setlease = cifs_setlease,
924 const struct file_operations cifs_file_direct_nobrl_ops = {
925 /* BB reevaluate whether they can be done with directio, no cache */
926 .read = do_sync_read,
927 .write = do_sync_write,
928 .aio_read = cifs_user_readv,
929 .aio_write = cifs_user_writev,
931 .release = cifs_close,
934 .mmap = cifs_file_mmap,
935 .splice_read = generic_file_splice_read,
936 #ifdef CONFIG_CIFS_POSIX
937 .unlocked_ioctl = cifs_ioctl,
938 #endif /* CONFIG_CIFS_POSIX */
939 .llseek = cifs_llseek,
940 .setlease = cifs_setlease,
943 const struct file_operations cifs_dir_ops = {
944 .readdir = cifs_readdir,
945 .release = cifs_closedir,
946 .read = generic_read_dir,
947 .unlocked_ioctl = cifs_ioctl,
948 .llseek = generic_file_llseek,
952 cifs_init_once(void *inode)
954 struct cifsInodeInfo *cifsi = inode;
956 inode_init_once(&cifsi->vfs_inode);
957 mutex_init(&cifsi->lock_mutex);
961 cifs_init_inodecache(void)
963 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
964 sizeof(struct cifsInodeInfo),
965 0, (SLAB_RECLAIM_ACCOUNT|
968 if (cifs_inode_cachep == NULL)
975 cifs_destroy_inodecache(void)
977 kmem_cache_destroy(cifs_inode_cachep);
981 cifs_init_request_bufs(void)
983 if (CIFSMaxBufSize < 8192) {
984 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
985 Unicode path name has to fit in any SMB/CIFS path based frames */
986 CIFSMaxBufSize = 8192;
987 } else if (CIFSMaxBufSize > 1024*127) {
988 CIFSMaxBufSize = 1024 * 127;
990 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
992 /* cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
993 cifs_req_cachep = kmem_cache_create("cifs_request",
995 MAX_CIFS_HDR_SIZE, 0,
996 SLAB_HWCACHE_ALIGN, NULL);
997 if (cifs_req_cachep == NULL)
1000 if (cifs_min_rcv < 1)
1002 else if (cifs_min_rcv > 64) {
1004 cERROR(1, "cifs_min_rcv set to maximum (64)");
1007 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1010 if (cifs_req_poolp == NULL) {
1011 kmem_cache_destroy(cifs_req_cachep);
1014 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1015 almost all handle based requests (but not write response, nor is it
1016 sufficient for path based requests). A smaller size would have
1017 been more efficient (compacting multiple slab items on one 4k page)
1018 for the case in which debug was on, but this larger size allows
1019 more SMBs to use small buffer alloc and is still much more
1020 efficient to alloc 1 per page off the slab compared to 17K (5page)
1021 alloc of large cifs buffers even when page debugging is on */
1022 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
1023 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1025 if (cifs_sm_req_cachep == NULL) {
1026 mempool_destroy(cifs_req_poolp);
1027 kmem_cache_destroy(cifs_req_cachep);
1031 if (cifs_min_small < 2)
1033 else if (cifs_min_small > 256) {
1034 cifs_min_small = 256;
1035 cFYI(1, "cifs_min_small set to maximum (256)");
1038 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1039 cifs_sm_req_cachep);
1041 if (cifs_sm_req_poolp == NULL) {
1042 mempool_destroy(cifs_req_poolp);
1043 kmem_cache_destroy(cifs_req_cachep);
1044 kmem_cache_destroy(cifs_sm_req_cachep);
1052 cifs_destroy_request_bufs(void)
1054 mempool_destroy(cifs_req_poolp);
1055 kmem_cache_destroy(cifs_req_cachep);
1056 mempool_destroy(cifs_sm_req_poolp);
1057 kmem_cache_destroy(cifs_sm_req_cachep);
1061 cifs_init_mids(void)
1063 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1064 sizeof(struct mid_q_entry), 0,
1065 SLAB_HWCACHE_ALIGN, NULL);
1066 if (cifs_mid_cachep == NULL)
1069 /* 3 is a reasonable minimum number of simultaneous operations */
1070 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1071 if (cifs_mid_poolp == NULL) {
1072 kmem_cache_destroy(cifs_mid_cachep);
1080 cifs_destroy_mids(void)
1082 mempool_destroy(cifs_mid_poolp);
1083 kmem_cache_destroy(cifs_mid_cachep);
1091 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1092 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1093 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1094 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1095 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1097 * Initialize Global counters
1099 atomic_set(&sesInfoAllocCount, 0);
1100 atomic_set(&tconInfoAllocCount, 0);
1101 atomic_set(&tcpSesAllocCount, 0);
1102 atomic_set(&tcpSesReconnectCount, 0);
1103 atomic_set(&tconInfoReconnectCount, 0);
1105 atomic_set(&bufAllocCount, 0);
1106 atomic_set(&smBufAllocCount, 0);
1107 #ifdef CONFIG_CIFS_STATS2
1108 atomic_set(&totBufAllocCount, 0);
1109 atomic_set(&totSmBufAllocCount, 0);
1110 #endif /* CONFIG_CIFS_STATS2 */
1112 atomic_set(&midCount, 0);
1113 GlobalCurrentXid = 0;
1114 GlobalTotalActiveXid = 0;
1115 GlobalMaxActiveXid = 0;
1116 spin_lock_init(&cifs_tcp_ses_lock);
1117 spin_lock_init(&cifs_file_list_lock);
1118 spin_lock_init(&GlobalMid_Lock);
1120 if (cifs_max_pending < 2) {
1121 cifs_max_pending = 2;
1122 cFYI(1, "cifs_max_pending set to min of 2");
1123 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1124 cifs_max_pending = CIFS_MAX_REQ;
1125 cFYI(1, "cifs_max_pending set to max of %u", CIFS_MAX_REQ);
1128 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1131 goto out_clean_proc;
1134 rc = cifs_fscache_register();
1136 goto out_destroy_wq;
1138 rc = cifs_init_inodecache();
1140 goto out_unreg_fscache;
1142 rc = cifs_init_mids();
1144 goto out_destroy_inodecache;
1146 rc = cifs_init_request_bufs();
1148 goto out_destroy_mids;
1150 #ifdef CONFIG_CIFS_UPCALL
1151 rc = register_key_type(&cifs_spnego_key_type);
1153 goto out_destroy_request_bufs;
1154 #endif /* CONFIG_CIFS_UPCALL */
1156 #ifdef CONFIG_CIFS_ACL
1157 rc = init_cifs_idmap();
1159 goto out_register_key_type;
1160 #endif /* CONFIG_CIFS_ACL */
1162 rc = register_filesystem(&cifs_fs_type);
1164 goto out_init_cifs_idmap;
1168 out_init_cifs_idmap:
1169 #ifdef CONFIG_CIFS_ACL
1171 out_register_key_type:
1173 #ifdef CONFIG_CIFS_UPCALL
1174 unregister_key_type(&cifs_spnego_key_type);
1175 out_destroy_request_bufs:
1177 cifs_destroy_request_bufs();
1179 cifs_destroy_mids();
1180 out_destroy_inodecache:
1181 cifs_destroy_inodecache();
1183 cifs_fscache_unregister();
1185 destroy_workqueue(cifsiod_wq);
1194 cFYI(DBG2, "exit_cifs");
1195 unregister_filesystem(&cifs_fs_type);
1196 cifs_dfs_release_automount_timer();
1197 #ifdef CONFIG_CIFS_ACL
1198 cifs_destroy_idmaptrees();
1201 #ifdef CONFIG_CIFS_UPCALL
1202 unregister_key_type(&cifs_spnego_key_type);
1204 cifs_destroy_request_bufs();
1205 cifs_destroy_mids();
1206 cifs_destroy_inodecache();
1207 cifs_fscache_unregister();
1208 destroy_workqueue(cifsiod_wq);
1212 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1213 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1215 ("VFS to access servers complying with the SNIA CIFS Specification "
1216 "e.g. Samba and Windows");
1217 MODULE_VERSION(CIFS_VERSION);
1218 module_init(init_cifs)
1219 module_exit(exit_cifs)