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 unsigned int oplockEnabled
= 1;
57 unsigned int linuxExtEnabled
= 1;
58 unsigned int lookupCacheEnabled
= 1;
59 unsigned int multiuser_mount
= 0;
60 unsigned int global_secflags
= CIFSSEC_DEF
;
61 /* unsigned int ntlmv2_support = 0; */
62 unsigned int sign_CIFS_PDUs
= 1;
63 static const struct super_operations cifs_super_ops
;
64 unsigned int CIFSMaxBufSize
= CIFS_MAX_MSGSIZE
;
65 module_param(CIFSMaxBufSize
, int, 0);
66 MODULE_PARM_DESC(CIFSMaxBufSize
, "Network buffer size (not including header). "
67 "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: "
72 unsigned int cifs_min_small
= 30;
73 module_param(cifs_min_small
, int, 0);
74 MODULE_PARM_DESC(cifs_min_small
, "Small network buffers in pool. Default: 30 "
76 unsigned int cifs_max_pending
= CIFS_MAX_REQ
;
77 module_param(cifs_max_pending
, int, 0);
78 MODULE_PARM_DESC(cifs_max_pending
, "Simultaneous requests to server. "
79 "Default: 50 Range: 2 to 256");
80 unsigned short echo_retries
= 5;
81 module_param(echo_retries
, ushort
, 0644);
82 MODULE_PARM_DESC(echo_retries
, "Number of echo attempts before giving up and "
83 "reconnecting server. Default: 5. 0 means "
85 extern mempool_t
*cifs_sm_req_poolp
;
86 extern mempool_t
*cifs_req_poolp
;
87 extern mempool_t
*cifs_mid_poolp
;
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
);
122 sb
->s_root
= d_alloc_root(inode
);
129 /* do that *after* d_alloc_root() - we want NULL ->d_op for root here */
130 if (cifs_sb_master_tcon(cifs_sb
)->nocase
)
131 sb
->s_d_op
= &cifs_ci_dentry_ops
;
133 sb
->s_d_op
= &cifs_dentry_ops
;
135 #ifdef CIFS_NFSD_EXPORT
136 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) {
137 cFYI(1, "export ops supported");
138 sb
->s_export_op
= &cifs_export_ops
;
140 #endif /* CIFS_NFSD_EXPORT */
145 cERROR(1, "cifs_read_super: get root inode failed");
152 static void cifs_kill_sb(struct super_block
*sb
)
154 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
156 cifs_umount(cifs_sb
);
160 cifs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
162 struct super_block
*sb
= dentry
->d_sb
;
163 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
164 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
165 int rc
= -EOPNOTSUPP
;
170 buf
->f_type
= CIFS_MAGIC_NUMBER
;
173 * PATH_MAX may be too long - it would presumably be total path,
174 * but note that some servers (includinng Samba 3) have a shorter
177 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
179 buf
->f_namelen
= PATH_MAX
;
180 buf
->f_files
= 0; /* undefined */
181 buf
->f_ffree
= 0; /* unlimited */
184 * We could add a second check for a QFS Unix capability bit
186 if ((tcon
->ses
->capabilities
& CAP_UNIX
) &&
187 (CIFS_POSIX_EXTENSIONS
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)))
188 rc
= CIFSSMBQFSPosixInfo(xid
, tcon
, buf
);
191 * Only need to call the old QFSInfo if failed on newer one,
194 if (rc
&& (tcon
->ses
->capabilities
& CAP_NT_SMBS
))
195 rc
= CIFSSMBQFSInfo(xid
, tcon
, buf
);
198 * Some old Windows servers also do not support level 103, retry with
199 * older level one if old server failed the previous call or we
200 * bypassed it because we detected that this was an older LANMAN sess
203 rc
= SMBOldQFSInfo(xid
, tcon
, buf
);
209 static int cifs_permission(struct inode
*inode
, int mask
)
211 struct cifs_sb_info
*cifs_sb
;
213 cifs_sb
= CIFS_SB(inode
->i_sb
);
215 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
) {
216 if ((mask
& MAY_EXEC
) && !execute_ok(inode
))
220 } else /* file mode might have been restricted at mount time
221 on the client (above and beyond ACL on servers) for
222 servers which do not support setting and viewing mode bits,
223 so allowing client to check permissions is useful */
224 return generic_permission(inode
, mask
);
227 static struct kmem_cache
*cifs_inode_cachep
;
228 static struct kmem_cache
*cifs_req_cachep
;
229 static struct kmem_cache
*cifs_mid_cachep
;
230 static struct kmem_cache
*cifs_sm_req_cachep
;
231 mempool_t
*cifs_sm_req_poolp
;
232 mempool_t
*cifs_req_poolp
;
233 mempool_t
*cifs_mid_poolp
;
235 static struct inode
*
236 cifs_alloc_inode(struct super_block
*sb
)
238 struct cifsInodeInfo
*cifs_inode
;
239 cifs_inode
= kmem_cache_alloc(cifs_inode_cachep
, GFP_KERNEL
);
242 cifs_inode
->cifsAttrs
= 0x20; /* default */
243 cifs_inode
->time
= 0;
244 /* Until the file is open and we have gotten oplock
245 info back from the server, can not assume caching of
246 file data or metadata */
247 cifs_set_oplock_level(cifs_inode
, 0);
248 cifs_inode
->delete_pending
= false;
249 cifs_inode
->invalid_mapping
= false;
250 cifs_inode
->vfs_inode
.i_blkbits
= 14; /* 2**14 = CIFS_MAX_MSGSIZE */
251 cifs_inode
->server_eof
= 0;
252 cifs_inode
->uniqueid
= 0;
253 cifs_inode
->createtime
= 0;
255 /* Can not set i_flags here - they get immediately overwritten
256 to zero by the VFS */
257 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
258 INIT_LIST_HEAD(&cifs_inode
->openFileList
);
259 return &cifs_inode
->vfs_inode
;
262 static void cifs_i_callback(struct rcu_head
*head
)
264 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
265 INIT_LIST_HEAD(&inode
->i_dentry
);
266 kmem_cache_free(cifs_inode_cachep
, CIFS_I(inode
));
270 cifs_destroy_inode(struct inode
*inode
)
272 call_rcu(&inode
->i_rcu
, cifs_i_callback
);
276 cifs_evict_inode(struct inode
*inode
)
278 truncate_inode_pages(&inode
->i_data
, 0);
279 end_writeback(inode
);
280 cifs_fscache_release_inode_cookie(inode
);
284 cifs_show_address(struct seq_file
*s
, struct TCP_Server_Info
*server
)
286 struct sockaddr_in
*sa
= (struct sockaddr_in
*) &server
->dstaddr
;
287 struct sockaddr_in6
*sa6
= (struct sockaddr_in6
*) &server
->dstaddr
;
289 seq_printf(s
, ",addr=");
291 switch (server
->dstaddr
.ss_family
) {
293 seq_printf(s
, "%pI4", &sa
->sin_addr
.s_addr
);
296 seq_printf(s
, "%pI6", &sa6
->sin6_addr
.s6_addr
);
297 if (sa6
->sin6_scope_id
)
298 seq_printf(s
, "%%%u", sa6
->sin6_scope_id
);
301 seq_printf(s
, "(unknown)");
306 cifs_show_security(struct seq_file
*s
, struct TCP_Server_Info
*server
)
308 seq_printf(s
, ",sec=");
310 switch (server
->secType
) {
312 seq_printf(s
, "lanman");
315 seq_printf(s
, "ntlmv2");
318 seq_printf(s
, "ntlm");
321 seq_printf(s
, "krb5");
324 seq_printf(s
, "ntlmssp");
327 /* shouldn't ever happen */
328 seq_printf(s
, "unknown");
332 if (server
->sec_mode
& (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
337 * cifs_show_options() is for displaying mount options in /proc/mounts.
338 * Not all settable options are displayed but most of the important
342 cifs_show_options(struct seq_file
*s
, struct vfsmount
*m
)
344 struct cifs_sb_info
*cifs_sb
= CIFS_SB(m
->mnt_sb
);
345 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
346 struct sockaddr
*srcaddr
;
347 srcaddr
= (struct sockaddr
*)&tcon
->ses
->server
->srcaddr
;
349 cifs_show_security(s
, tcon
->ses
->server
);
351 seq_printf(s
, ",unc=%s", tcon
->treeName
);
353 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
)
354 seq_printf(s
, ",multiuser");
355 else if (tcon
->ses
->user_name
)
356 seq_printf(s
, ",username=%s", tcon
->ses
->user_name
);
358 if (tcon
->ses
->domainName
)
359 seq_printf(s
, ",domain=%s", tcon
->ses
->domainName
);
361 if (srcaddr
->sa_family
!= AF_UNSPEC
) {
362 struct sockaddr_in
*saddr4
;
363 struct sockaddr_in6
*saddr6
;
364 saddr4
= (struct sockaddr_in
*)srcaddr
;
365 saddr6
= (struct sockaddr_in6
*)srcaddr
;
366 if (srcaddr
->sa_family
== AF_INET6
)
367 seq_printf(s
, ",srcaddr=%pI6c",
369 else if (srcaddr
->sa_family
== AF_INET
)
370 seq_printf(s
, ",srcaddr=%pI4",
371 &saddr4
->sin_addr
.s_addr
);
373 seq_printf(s
, ",srcaddr=BAD-AF:%i",
374 (int)(srcaddr
->sa_family
));
377 seq_printf(s
, ",uid=%d", cifs_sb
->mnt_uid
);
378 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_UID
)
379 seq_printf(s
, ",forceuid");
381 seq_printf(s
, ",noforceuid");
383 seq_printf(s
, ",gid=%d", cifs_sb
->mnt_gid
);
384 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_GID
)
385 seq_printf(s
, ",forcegid");
387 seq_printf(s
, ",noforcegid");
389 cifs_show_address(s
, tcon
->ses
->server
);
392 seq_printf(s
, ",file_mode=0%o,dir_mode=0%o",
393 cifs_sb
->mnt_file_mode
,
394 cifs_sb
->mnt_dir_mode
);
396 seq_printf(s
, ",seal");
398 seq_printf(s
, ",nocase");
400 seq_printf(s
, ",hard");
402 seq_printf(s
, ",unix");
404 seq_printf(s
, ",nounix");
405 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
)
406 seq_printf(s
, ",posixpaths");
407 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
)
408 seq_printf(s
, ",setuids");
409 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
)
410 seq_printf(s
, ",serverino");
411 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
412 seq_printf(s
, ",rwpidforward");
413 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
)
414 seq_printf(s
, ",forcemand");
415 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
)
416 seq_printf(s
, ",directio");
417 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_XATTR
)
418 seq_printf(s
, ",nouser_xattr");
419 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
)
420 seq_printf(s
, ",mapchars");
421 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
)
422 seq_printf(s
, ",sfu");
423 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
424 seq_printf(s
, ",nobrl");
425 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
)
426 seq_printf(s
, ",cifsacl");
427 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)
428 seq_printf(s
, ",dynperm");
429 if (m
->mnt_sb
->s_flags
& MS_POSIXACL
)
430 seq_printf(s
, ",acl");
431 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MF_SYMLINKS
)
432 seq_printf(s
, ",mfsymlinks");
433 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_FSCACHE
)
434 seq_printf(s
, ",fsc");
435 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_STRICT_IO
)
436 seq_printf(s
, ",strictcache");
438 seq_printf(s
, ",rsize=%d", cifs_sb
->rsize
);
439 seq_printf(s
, ",wsize=%d", cifs_sb
->wsize
);
440 /* convert actimeo and display it in seconds */
441 seq_printf(s
, ",actimeo=%lu", cifs_sb
->actimeo
/ HZ
);
446 static void cifs_umount_begin(struct super_block
*sb
)
448 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
449 struct cifs_tcon
*tcon
;
454 tcon
= cifs_sb_master_tcon(cifs_sb
);
456 spin_lock(&cifs_tcp_ses_lock
);
457 if ((tcon
->tc_count
> 1) || (tcon
->tidStatus
== CifsExiting
)) {
458 /* we have other mounts to same share or we have
459 already tried to force umount this and woken up
460 all waiting network requests, nothing to do */
461 spin_unlock(&cifs_tcp_ses_lock
);
463 } else if (tcon
->tc_count
== 1)
464 tcon
->tidStatus
= CifsExiting
;
465 spin_unlock(&cifs_tcp_ses_lock
);
467 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
468 /* cancel_notify_requests(tcon); */
469 if (tcon
->ses
&& tcon
->ses
->server
) {
470 cFYI(1, "wake up tasks now - umount begin not complete");
471 wake_up_all(&tcon
->ses
->server
->request_q
);
472 wake_up_all(&tcon
->ses
->server
->response_q
);
473 msleep(1); /* yield */
474 /* we have to kick the requests once more */
475 wake_up_all(&tcon
->ses
->server
->response_q
);
482 #ifdef CONFIG_CIFS_STATS2
483 static int cifs_show_stats(struct seq_file
*s
, struct vfsmount
*mnt
)
490 static int cifs_remount(struct super_block
*sb
, int *flags
, char *data
)
492 *flags
|= MS_NODIRATIME
;
496 static int cifs_drop_inode(struct inode
*inode
)
498 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
500 /* no serverino => unconditional eviction */
501 return !(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) ||
502 generic_drop_inode(inode
);
505 static const struct super_operations cifs_super_ops
= {
506 .statfs
= cifs_statfs
,
507 .alloc_inode
= cifs_alloc_inode
,
508 .destroy_inode
= cifs_destroy_inode
,
509 .drop_inode
= cifs_drop_inode
,
510 .evict_inode
= cifs_evict_inode
,
511 /* .delete_inode = cifs_delete_inode, */ /* Do not need above
512 function unless later we add lazy close of inodes or unless the
513 kernel forgets to call us with the same number of releases (closes)
515 .show_options
= cifs_show_options
,
516 .umount_begin
= cifs_umount_begin
,
517 .remount_fs
= cifs_remount
,
518 #ifdef CONFIG_CIFS_STATS2
519 .show_stats
= cifs_show_stats
,
524 * Get root dentry from superblock according to prefix path mount option.
525 * Return dentry with refcount + 1 on success and NULL otherwise.
527 static struct dentry
*
528 cifs_get_root(struct smb_vol
*vol
, struct super_block
*sb
)
530 struct dentry
*dentry
;
531 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
532 char *full_path
= NULL
;
536 full_path
= cifs_build_path_to_root(vol
, cifs_sb
,
537 cifs_sb_master_tcon(cifs_sb
));
538 if (full_path
== NULL
)
539 return ERR_PTR(-ENOMEM
);
541 cFYI(1, "Get root dentry for %s", full_path
);
543 sep
= CIFS_DIR_SEP(cifs_sb
);
544 dentry
= dget(sb
->s_root
);
548 struct inode
*dir
= dentry
->d_inode
;
549 struct dentry
*child
;
553 dentry
= ERR_PTR(-ENOENT
);
557 /* skip separators */
564 while (*s
&& *s
!= sep
)
567 mutex_lock(&dir
->i_mutex
);
568 child
= lookup_one_len(p
, dentry
, s
- p
);
569 mutex_unlock(&dir
->i_mutex
);
572 } while (!IS_ERR(dentry
));
577 static int cifs_set_super(struct super_block
*sb
, void *data
)
579 struct cifs_mnt_data
*mnt_data
= data
;
580 sb
->s_fs_info
= mnt_data
->cifs_sb
;
581 return set_anon_super(sb
, NULL
);
584 static struct dentry
*
585 cifs_do_mount(struct file_system_type
*fs_type
,
586 int flags
, const char *dev_name
, void *data
)
589 struct super_block
*sb
;
590 struct cifs_sb_info
*cifs_sb
;
591 struct smb_vol
*volume_info
;
592 struct cifs_mnt_data mnt_data
;
595 cFYI(1, "Devname: %s flags: %d ", dev_name
, flags
);
597 volume_info
= cifs_get_volume_info((char *)data
, dev_name
);
598 if (IS_ERR(volume_info
))
599 return ERR_CAST(volume_info
);
601 cifs_sb
= kzalloc(sizeof(struct cifs_sb_info
), GFP_KERNEL
);
602 if (cifs_sb
== NULL
) {
603 root
= ERR_PTR(-ENOMEM
);
607 cifs_sb
->mountdata
= kstrndup(data
, PAGE_SIZE
, GFP_KERNEL
);
608 if (cifs_sb
->mountdata
== NULL
) {
609 root
= ERR_PTR(-ENOMEM
);
613 cifs_setup_cifs_sb(volume_info
, cifs_sb
);
615 rc
= cifs_mount(cifs_sb
, volume_info
);
617 if (!(flags
& MS_SILENT
))
618 cERROR(1, "cifs_mount failed w/return code = %d", rc
);
623 mnt_data
.vol
= volume_info
;
624 mnt_data
.cifs_sb
= cifs_sb
;
625 mnt_data
.flags
= flags
;
627 sb
= sget(fs_type
, cifs_match_super
, cifs_set_super
, &mnt_data
);
630 cifs_umount(cifs_sb
);
635 cFYI(1, "Use existing superblock");
636 cifs_umount(cifs_sb
);
639 /* BB should we make this contingent on mount parm? */
640 sb
->s_flags
|= MS_NODIRATIME
| MS_NOATIME
;
642 rc
= cifs_read_super(sb
);
648 sb
->s_flags
|= MS_ACTIVE
;
651 root
= cifs_get_root(volume_info
, sb
);
655 cFYI(1, "dentry root is: %p", root
);
659 deactivate_locked_super(sb
);
661 cifs_cleanup_volume_info(volume_info
);
665 kfree(cifs_sb
->mountdata
);
669 unload_nls(volume_info
->local_nls
);
673 static ssize_t
cifs_file_aio_write(struct kiocb
*iocb
, const struct iovec
*iov
,
674 unsigned long nr_segs
, loff_t pos
)
676 struct inode
*inode
= iocb
->ki_filp
->f_path
.dentry
->d_inode
;
680 written
= generic_file_aio_write(iocb
, iov
, nr_segs
, pos
);
682 if (CIFS_I(inode
)->clientCanCacheAll
)
685 rc
= filemap_fdatawrite(inode
->i_mapping
);
687 cFYI(1, "cifs_file_aio_write: %d rc on %p inode", rc
, inode
);
692 static loff_t
cifs_llseek(struct file
*file
, loff_t offset
, int origin
)
695 * origin == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
696 * the cached file length
698 if (origin
!= SEEK_SET
|| origin
!= SEEK_CUR
) {
700 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
703 * We need to be sure that all dirty pages are written and the
704 * server has the newest file length.
706 if (!CIFS_I(inode
)->clientCanCacheRead
&& inode
->i_mapping
&&
707 inode
->i_mapping
->nrpages
!= 0) {
708 rc
= filemap_fdatawait(inode
->i_mapping
);
710 mapping_set_error(inode
->i_mapping
, rc
);
715 * Some applications poll for the file length in this strange
716 * way so we must seek to end on non-oplocked files by
717 * setting the revalidate time to zero.
719 CIFS_I(inode
)->time
= 0;
721 rc
= cifs_revalidate_file_attr(file
);
725 return generic_file_llseek_unlocked(file
, offset
, origin
);
728 static int cifs_setlease(struct file
*file
, long arg
, struct file_lock
**lease
)
730 /* note that this is called by vfs setlease with lock_flocks held
731 to protect *lease from going away */
732 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
733 struct cifsFileInfo
*cfile
= file
->private_data
;
735 if (!(S_ISREG(inode
->i_mode
)))
738 /* check if file is oplocked */
739 if (((arg
== F_RDLCK
) &&
740 (CIFS_I(inode
)->clientCanCacheRead
)) ||
742 (CIFS_I(inode
)->clientCanCacheAll
)))
743 return generic_setlease(file
, arg
, lease
);
744 else if (tlink_tcon(cfile
->tlink
)->local_lease
&&
745 !CIFS_I(inode
)->clientCanCacheRead
)
746 /* If the server claims to support oplock on this
747 file, then we still need to check oplock even
748 if the local_lease mount option is set, but there
749 are servers which do not support oplock for which
750 this mount option may be useful if the user
751 knows that the file won't be changed on the server
753 return generic_setlease(file
, arg
, lease
);
758 struct file_system_type cifs_fs_type
= {
759 .owner
= THIS_MODULE
,
761 .mount
= cifs_do_mount
,
762 .kill_sb
= cifs_kill_sb
,
765 const struct inode_operations cifs_dir_inode_ops
= {
766 .create
= cifs_create
,
767 .lookup
= cifs_lookup
,
768 .getattr
= cifs_getattr
,
769 .unlink
= cifs_unlink
,
770 .link
= cifs_hardlink
,
773 .rename
= cifs_rename
,
774 .permission
= cifs_permission
,
775 /* revalidate:cifs_revalidate, */
776 .setattr
= cifs_setattr
,
777 .symlink
= cifs_symlink
,
779 #ifdef CONFIG_CIFS_XATTR
780 .setxattr
= cifs_setxattr
,
781 .getxattr
= cifs_getxattr
,
782 .listxattr
= cifs_listxattr
,
783 .removexattr
= cifs_removexattr
,
787 const struct inode_operations cifs_file_inode_ops
= {
788 /* revalidate:cifs_revalidate, */
789 .setattr
= cifs_setattr
,
790 .getattr
= cifs_getattr
, /* do we need this anymore? */
791 .rename
= cifs_rename
,
792 .permission
= cifs_permission
,
793 #ifdef CONFIG_CIFS_XATTR
794 .setxattr
= cifs_setxattr
,
795 .getxattr
= cifs_getxattr
,
796 .listxattr
= cifs_listxattr
,
797 .removexattr
= cifs_removexattr
,
801 const struct inode_operations cifs_symlink_inode_ops
= {
802 .readlink
= generic_readlink
,
803 .follow_link
= cifs_follow_link
,
804 .put_link
= cifs_put_link
,
805 .permission
= cifs_permission
,
806 /* BB add the following two eventually */
807 /* revalidate: cifs_revalidate,
808 setattr: cifs_notify_change, *//* BB do we need notify change */
809 #ifdef CONFIG_CIFS_XATTR
810 .setxattr
= cifs_setxattr
,
811 .getxattr
= cifs_getxattr
,
812 .listxattr
= cifs_listxattr
,
813 .removexattr
= cifs_removexattr
,
817 const struct file_operations cifs_file_ops
= {
818 .read
= do_sync_read
,
819 .write
= do_sync_write
,
820 .aio_read
= generic_file_aio_read
,
821 .aio_write
= cifs_file_aio_write
,
823 .release
= cifs_close
,
827 .mmap
= cifs_file_mmap
,
828 .splice_read
= generic_file_splice_read
,
829 .llseek
= cifs_llseek
,
830 #ifdef CONFIG_CIFS_POSIX
831 .unlocked_ioctl
= cifs_ioctl
,
832 #endif /* CONFIG_CIFS_POSIX */
833 .setlease
= cifs_setlease
,
836 const struct file_operations cifs_file_strict_ops
= {
837 .read
= do_sync_read
,
838 .write
= do_sync_write
,
839 .aio_read
= cifs_strict_readv
,
840 .aio_write
= cifs_strict_writev
,
842 .release
= cifs_close
,
844 .fsync
= cifs_strict_fsync
,
846 .mmap
= cifs_file_strict_mmap
,
847 .splice_read
= generic_file_splice_read
,
848 .llseek
= cifs_llseek
,
849 #ifdef CONFIG_CIFS_POSIX
850 .unlocked_ioctl
= cifs_ioctl
,
851 #endif /* CONFIG_CIFS_POSIX */
852 .setlease
= cifs_setlease
,
855 const struct file_operations cifs_file_direct_ops
= {
856 /* BB reevaluate whether they can be done with directio, no cache */
857 .read
= do_sync_read
,
858 .write
= do_sync_write
,
859 .aio_read
= cifs_user_readv
,
860 .aio_write
= cifs_user_writev
,
862 .release
= cifs_close
,
866 .mmap
= cifs_file_mmap
,
867 .splice_read
= generic_file_splice_read
,
868 #ifdef CONFIG_CIFS_POSIX
869 .unlocked_ioctl
= cifs_ioctl
,
870 #endif /* CONFIG_CIFS_POSIX */
871 .llseek
= cifs_llseek
,
872 .setlease
= cifs_setlease
,
875 const struct file_operations cifs_file_nobrl_ops
= {
876 .read
= do_sync_read
,
877 .write
= do_sync_write
,
878 .aio_read
= generic_file_aio_read
,
879 .aio_write
= cifs_file_aio_write
,
881 .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_nobrl_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
,
900 .fsync
= cifs_strict_fsync
,
902 .mmap
= cifs_file_strict_mmap
,
903 .splice_read
= generic_file_splice_read
,
904 .llseek
= cifs_llseek
,
905 #ifdef CONFIG_CIFS_POSIX
906 .unlocked_ioctl
= cifs_ioctl
,
907 #endif /* CONFIG_CIFS_POSIX */
908 .setlease
= cifs_setlease
,
911 const struct file_operations cifs_file_direct_nobrl_ops
= {
912 /* BB reevaluate whether they can be done with directio, no cache */
913 .read
= do_sync_read
,
914 .write
= do_sync_write
,
915 .aio_read
= cifs_user_readv
,
916 .aio_write
= cifs_user_writev
,
918 .release
= cifs_close
,
921 .mmap
= cifs_file_mmap
,
922 .splice_read
= generic_file_splice_read
,
923 #ifdef CONFIG_CIFS_POSIX
924 .unlocked_ioctl
= cifs_ioctl
,
925 #endif /* CONFIG_CIFS_POSIX */
926 .llseek
= cifs_llseek
,
927 .setlease
= cifs_setlease
,
930 const struct file_operations cifs_dir_ops
= {
931 .readdir
= cifs_readdir
,
932 .release
= cifs_closedir
,
933 .read
= generic_read_dir
,
934 .unlocked_ioctl
= cifs_ioctl
,
935 .llseek
= generic_file_llseek
,
939 cifs_init_once(void *inode
)
941 struct cifsInodeInfo
*cifsi
= inode
;
943 inode_init_once(&cifsi
->vfs_inode
);
944 INIT_LIST_HEAD(&cifsi
->lockList
);
948 cifs_init_inodecache(void)
950 cifs_inode_cachep
= kmem_cache_create("cifs_inode_cache",
951 sizeof(struct cifsInodeInfo
),
952 0, (SLAB_RECLAIM_ACCOUNT
|
955 if (cifs_inode_cachep
== NULL
)
962 cifs_destroy_inodecache(void)
964 kmem_cache_destroy(cifs_inode_cachep
);
968 cifs_init_request_bufs(void)
970 if (CIFSMaxBufSize
< 8192) {
971 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
972 Unicode path name has to fit in any SMB/CIFS path based frames */
973 CIFSMaxBufSize
= 8192;
974 } else if (CIFSMaxBufSize
> 1024*127) {
975 CIFSMaxBufSize
= 1024 * 127;
977 CIFSMaxBufSize
&= 0x1FE00; /* Round size to even 512 byte mult*/
979 /* cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
980 cifs_req_cachep
= kmem_cache_create("cifs_request",
982 MAX_CIFS_HDR_SIZE
, 0,
983 SLAB_HWCACHE_ALIGN
, NULL
);
984 if (cifs_req_cachep
== NULL
)
987 if (cifs_min_rcv
< 1)
989 else if (cifs_min_rcv
> 64) {
991 cERROR(1, "cifs_min_rcv set to maximum (64)");
994 cifs_req_poolp
= mempool_create_slab_pool(cifs_min_rcv
,
997 if (cifs_req_poolp
== NULL
) {
998 kmem_cache_destroy(cifs_req_cachep
);
1001 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1002 almost all handle based requests (but not write response, nor is it
1003 sufficient for path based requests). A smaller size would have
1004 been more efficient (compacting multiple slab items on one 4k page)
1005 for the case in which debug was on, but this larger size allows
1006 more SMBs to use small buffer alloc and is still much more
1007 efficient to alloc 1 per page off the slab compared to 17K (5page)
1008 alloc of large cifs buffers even when page debugging is on */
1009 cifs_sm_req_cachep
= kmem_cache_create("cifs_small_rq",
1010 MAX_CIFS_SMALL_BUFFER_SIZE
, 0, SLAB_HWCACHE_ALIGN
,
1012 if (cifs_sm_req_cachep
== NULL
) {
1013 mempool_destroy(cifs_req_poolp
);
1014 kmem_cache_destroy(cifs_req_cachep
);
1018 if (cifs_min_small
< 2)
1020 else if (cifs_min_small
> 256) {
1021 cifs_min_small
= 256;
1022 cFYI(1, "cifs_min_small set to maximum (256)");
1025 cifs_sm_req_poolp
= mempool_create_slab_pool(cifs_min_small
,
1026 cifs_sm_req_cachep
);
1028 if (cifs_sm_req_poolp
== NULL
) {
1029 mempool_destroy(cifs_req_poolp
);
1030 kmem_cache_destroy(cifs_req_cachep
);
1031 kmem_cache_destroy(cifs_sm_req_cachep
);
1039 cifs_destroy_request_bufs(void)
1041 mempool_destroy(cifs_req_poolp
);
1042 kmem_cache_destroy(cifs_req_cachep
);
1043 mempool_destroy(cifs_sm_req_poolp
);
1044 kmem_cache_destroy(cifs_sm_req_cachep
);
1048 cifs_init_mids(void)
1050 cifs_mid_cachep
= kmem_cache_create("cifs_mpx_ids",
1051 sizeof(struct mid_q_entry
), 0,
1052 SLAB_HWCACHE_ALIGN
, NULL
);
1053 if (cifs_mid_cachep
== NULL
)
1056 /* 3 is a reasonable minimum number of simultaneous operations */
1057 cifs_mid_poolp
= mempool_create_slab_pool(3, cifs_mid_cachep
);
1058 if (cifs_mid_poolp
== NULL
) {
1059 kmem_cache_destroy(cifs_mid_cachep
);
1067 cifs_destroy_mids(void)
1069 mempool_destroy(cifs_mid_poolp
);
1070 kmem_cache_destroy(cifs_mid_cachep
);
1078 INIT_LIST_HEAD(&cifs_tcp_ses_list
);
1079 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1080 INIT_LIST_HEAD(&GlobalDnotifyReqList
);
1081 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q
);
1082 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1084 * Initialize Global counters
1086 atomic_set(&sesInfoAllocCount
, 0);
1087 atomic_set(&tconInfoAllocCount
, 0);
1088 atomic_set(&tcpSesAllocCount
, 0);
1089 atomic_set(&tcpSesReconnectCount
, 0);
1090 atomic_set(&tconInfoReconnectCount
, 0);
1092 atomic_set(&bufAllocCount
, 0);
1093 atomic_set(&smBufAllocCount
, 0);
1094 #ifdef CONFIG_CIFS_STATS2
1095 atomic_set(&totBufAllocCount
, 0);
1096 atomic_set(&totSmBufAllocCount
, 0);
1097 #endif /* CONFIG_CIFS_STATS2 */
1099 atomic_set(&midCount
, 0);
1100 GlobalCurrentXid
= 0;
1101 GlobalTotalActiveXid
= 0;
1102 GlobalMaxActiveXid
= 0;
1103 spin_lock_init(&cifs_tcp_ses_lock
);
1104 spin_lock_init(&cifs_file_list_lock
);
1105 spin_lock_init(&GlobalMid_Lock
);
1107 if (cifs_max_pending
< 2) {
1108 cifs_max_pending
= 2;
1109 cFYI(1, "cifs_max_pending set to min of 2");
1110 } else if (cifs_max_pending
> 256) {
1111 cifs_max_pending
= 256;
1112 cFYI(1, "cifs_max_pending set to max of 256");
1115 rc
= cifs_fscache_register();
1117 goto out_clean_proc
;
1119 rc
= cifs_init_inodecache();
1121 goto out_unreg_fscache
;
1123 rc
= cifs_init_mids();
1125 goto out_destroy_inodecache
;
1127 rc
= cifs_init_request_bufs();
1129 goto out_destroy_mids
;
1131 #ifdef CONFIG_CIFS_UPCALL
1132 rc
= register_key_type(&cifs_spnego_key_type
);
1134 goto out_destroy_request_bufs
;
1135 #endif /* CONFIG_CIFS_UPCALL */
1137 #ifdef CONFIG_CIFS_ACL
1138 rc
= init_cifs_idmap();
1140 goto out_register_key_type
;
1141 #endif /* CONFIG_CIFS_ACL */
1143 rc
= register_filesystem(&cifs_fs_type
);
1145 goto out_init_cifs_idmap
;
1149 out_init_cifs_idmap
:
1150 #ifdef CONFIG_CIFS_ACL
1152 out_register_key_type
:
1154 #ifdef CONFIG_CIFS_UPCALL
1155 unregister_key_type(&cifs_spnego_key_type
);
1156 out_destroy_request_bufs
:
1158 cifs_destroy_request_bufs();
1160 cifs_destroy_mids();
1161 out_destroy_inodecache
:
1162 cifs_destroy_inodecache();
1164 cifs_fscache_unregister();
1173 cFYI(DBG2
, "exit_cifs");
1175 cifs_fscache_unregister();
1176 #ifdef CONFIG_CIFS_DFS_UPCALL
1177 cifs_dfs_release_automount_timer();
1179 #ifdef CONFIG_CIFS_ACL
1180 cifs_destroy_idmaptrees();
1183 #ifdef CONFIG_CIFS_UPCALL
1184 unregister_key_type(&cifs_spnego_key_type
);
1186 unregister_filesystem(&cifs_fs_type
);
1187 cifs_destroy_inodecache();
1188 cifs_destroy_mids();
1189 cifs_destroy_request_bufs();
1192 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1193 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1195 ("VFS to access servers complying with the SNIA CIFS Specification "
1196 "e.g. Samba and Windows");
1197 MODULE_VERSION(CIFS_VERSION
);
1198 module_init(init_cifs
)
1199 module_exit(exit_cifs
)