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>
39 #include <linux/random.h>
40 #include <linux/xattr.h>
44 #define DECLARE_GLOBALS_HERE
46 #include "cifsproto.h"
47 #include "cifs_debug.h"
48 #include "cifs_fs_sb.h"
50 #include <linux/key-type.h>
51 #include "cifs_spnego.h"
53 #ifdef CONFIG_CIFS_SMB2
59 bool enable_oplocks
= true;
60 bool linuxExtEnabled
= true;
61 bool lookupCacheEnabled
= true;
62 unsigned int global_secflags
= CIFSSEC_DEF
;
63 /* unsigned int ntlmv2_support = 0; */
64 unsigned int sign_CIFS_PDUs
= 1;
65 static const struct super_operations cifs_super_ops
;
66 unsigned int CIFSMaxBufSize
= CIFS_MAX_MSGSIZE
;
67 module_param(CIFSMaxBufSize
, uint
, 0);
68 MODULE_PARM_DESC(CIFSMaxBufSize
, "Network buffer size (not including header). "
69 "Default: 16384 Range: 8192 to 130048");
70 unsigned int cifs_min_rcv
= CIFS_MIN_RCV_POOL
;
71 module_param(cifs_min_rcv
, uint
, 0);
72 MODULE_PARM_DESC(cifs_min_rcv
, "Network buffers in pool. Default: 4 Range: "
74 unsigned int cifs_min_small
= 30;
75 module_param(cifs_min_small
, uint
, 0);
76 MODULE_PARM_DESC(cifs_min_small
, "Small network buffers in pool. Default: 30 "
78 unsigned int cifs_max_pending
= CIFS_MAX_REQ
;
79 module_param(cifs_max_pending
, uint
, 0444);
80 MODULE_PARM_DESC(cifs_max_pending
, "Simultaneous requests to server. "
81 "Default: 32767 Range: 2 to 32767.");
82 module_param(enable_oplocks
, bool, 0644);
83 MODULE_PARM_DESC(enable_oplocks
, "Enable or disable oplocks. Default: y/Y/1");
85 extern mempool_t
*cifs_sm_req_poolp
;
86 extern mempool_t
*cifs_req_poolp
;
87 extern mempool_t
*cifs_mid_poolp
;
89 struct workqueue_struct
*cifsiod_wq
;
90 __u32 cifs_lock_secret
;
93 * Bumps refcount for cifs super block.
94 * Note that it should be only called if a referece to VFS super block is
95 * already held, e.g. in open-type syscalls context. Otherwise it can race with
96 * atomic_dec_and_test in deactivate_locked_super.
99 cifs_sb_active(struct super_block
*sb
)
101 struct cifs_sb_info
*server
= CIFS_SB(sb
);
103 if (atomic_inc_return(&server
->active
) == 1)
104 atomic_inc(&sb
->s_active
);
108 cifs_sb_deactive(struct super_block
*sb
)
110 struct cifs_sb_info
*server
= CIFS_SB(sb
);
112 if (atomic_dec_and_test(&server
->active
))
113 deactivate_super(sb
);
117 cifs_read_super(struct super_block
*sb
)
120 struct cifs_sb_info
*cifs_sb
;
121 struct cifs_tcon
*tcon
;
124 cifs_sb
= CIFS_SB(sb
);
125 tcon
= cifs_sb_master_tcon(cifs_sb
);
127 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIXACL
)
128 sb
->s_flags
|= MS_POSIXACL
;
130 if (tcon
->ses
->capabilities
& tcon
->ses
->server
->vals
->cap_large_files
)
131 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
133 sb
->s_maxbytes
= MAX_NON_LFS
;
135 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
136 sb
->s_time_gran
= 100;
138 sb
->s_magic
= CIFS_MAGIC_NUMBER
;
139 sb
->s_op
= &cifs_super_ops
;
140 sb
->s_xattr
= cifs_xattr_handlers
;
141 sb
->s_bdi
= &cifs_sb
->bdi
;
142 sb
->s_blocksize
= CIFS_MAX_MSGSIZE
;
143 sb
->s_blocksize_bits
= 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
144 inode
= cifs_root_iget(sb
);
152 sb
->s_d_op
= &cifs_ci_dentry_ops
;
154 sb
->s_d_op
= &cifs_dentry_ops
;
156 sb
->s_root
= d_make_root(inode
);
162 #ifdef CONFIG_CIFS_NFSD_EXPORT
163 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) {
164 cifs_dbg(FYI
, "export ops supported\n");
165 sb
->s_export_op
= &cifs_export_ops
;
167 #endif /* CONFIG_CIFS_NFSD_EXPORT */
172 cifs_dbg(VFS
, "%s: get root inode failed\n", __func__
);
176 static void cifs_kill_sb(struct super_block
*sb
)
178 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
180 cifs_umount(cifs_sb
);
184 cifs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
186 struct super_block
*sb
= dentry
->d_sb
;
187 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
188 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
189 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
196 * PATH_MAX may be too long - it would presumably be total path,
197 * but note that some servers (includinng Samba 3) have a shorter
200 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
202 buf
->f_namelen
= PATH_MAX
;
203 buf
->f_files
= 0; /* undefined */
204 buf
->f_ffree
= 0; /* unlimited */
206 if (server
->ops
->queryfs
)
207 rc
= server
->ops
->queryfs(xid
, tcon
, buf
);
213 static long cifs_fallocate(struct file
*file
, int mode
, loff_t off
, loff_t len
)
215 struct cifs_sb_info
*cifs_sb
= CIFS_FILE_SB(file
);
216 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
217 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
219 if (server
->ops
->fallocate
)
220 return server
->ops
->fallocate(file
, tcon
, mode
, off
, len
);
225 static int cifs_permission(struct inode
*inode
, int mask
)
227 struct cifs_sb_info
*cifs_sb
;
229 cifs_sb
= CIFS_SB(inode
->i_sb
);
231 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
) {
232 if ((mask
& MAY_EXEC
) && !execute_ok(inode
))
236 } else /* file mode might have been restricted at mount time
237 on the client (above and beyond ACL on servers) for
238 servers which do not support setting and viewing mode bits,
239 so allowing client to check permissions is useful */
240 return generic_permission(inode
, mask
);
243 static struct kmem_cache
*cifs_inode_cachep
;
244 static struct kmem_cache
*cifs_req_cachep
;
245 static struct kmem_cache
*cifs_mid_cachep
;
246 static struct kmem_cache
*cifs_sm_req_cachep
;
247 mempool_t
*cifs_sm_req_poolp
;
248 mempool_t
*cifs_req_poolp
;
249 mempool_t
*cifs_mid_poolp
;
251 static struct inode
*
252 cifs_alloc_inode(struct super_block
*sb
)
254 struct cifsInodeInfo
*cifs_inode
;
255 cifs_inode
= kmem_cache_alloc(cifs_inode_cachep
, GFP_KERNEL
);
258 cifs_inode
->cifsAttrs
= 0x20; /* default */
259 cifs_inode
->time
= 0;
261 * Until the file is open and we have gotten oplock info back from the
262 * server, can not assume caching of file data or metadata.
264 cifs_set_oplock_level(cifs_inode
, 0);
265 cifs_inode
->flags
= 0;
266 spin_lock_init(&cifs_inode
->writers_lock
);
267 cifs_inode
->writers
= 0;
268 cifs_inode
->vfs_inode
.i_blkbits
= 14; /* 2**14 = CIFS_MAX_MSGSIZE */
269 cifs_inode
->server_eof
= 0;
270 cifs_inode
->uniqueid
= 0;
271 cifs_inode
->createtime
= 0;
272 cifs_inode
->epoch
= 0;
273 #ifdef CONFIG_CIFS_SMB2
274 get_random_bytes(cifs_inode
->lease_key
, SMB2_LEASE_KEY_SIZE
);
277 * Can not set i_flags here - they get immediately overwritten to zero
280 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
281 INIT_LIST_HEAD(&cifs_inode
->openFileList
);
282 INIT_LIST_HEAD(&cifs_inode
->llist
);
283 return &cifs_inode
->vfs_inode
;
286 static void cifs_i_callback(struct rcu_head
*head
)
288 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
289 kmem_cache_free(cifs_inode_cachep
, CIFS_I(inode
));
293 cifs_destroy_inode(struct inode
*inode
)
295 call_rcu(&inode
->i_rcu
, cifs_i_callback
);
299 cifs_evict_inode(struct inode
*inode
)
301 truncate_inode_pages_final(&inode
->i_data
);
303 cifs_fscache_release_inode_cookie(inode
);
307 cifs_show_address(struct seq_file
*s
, struct TCP_Server_Info
*server
)
309 struct sockaddr_in
*sa
= (struct sockaddr_in
*) &server
->dstaddr
;
310 struct sockaddr_in6
*sa6
= (struct sockaddr_in6
*) &server
->dstaddr
;
312 seq_puts(s
, ",addr=");
314 switch (server
->dstaddr
.ss_family
) {
316 seq_printf(s
, "%pI4", &sa
->sin_addr
.s_addr
);
319 seq_printf(s
, "%pI6", &sa6
->sin6_addr
.s6_addr
);
320 if (sa6
->sin6_scope_id
)
321 seq_printf(s
, "%%%u", sa6
->sin6_scope_id
);
324 seq_puts(s
, "(unknown)");
329 cifs_show_security(struct seq_file
*s
, struct cifs_ses
*ses
)
331 if (ses
->sectype
== Unspecified
) {
332 if (ses
->user_name
== NULL
)
333 seq_puts(s
, ",sec=none");
337 seq_puts(s
, ",sec=");
339 switch (ses
->sectype
) {
341 seq_puts(s
, "lanman");
344 seq_puts(s
, "ntlmv2");
353 seq_puts(s
, "ntlmssp");
356 /* shouldn't ever happen */
357 seq_puts(s
, "unknown");
366 cifs_show_cache_flavor(struct seq_file
*s
, struct cifs_sb_info
*cifs_sb
)
368 seq_puts(s
, ",cache=");
370 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_STRICT_IO
)
371 seq_puts(s
, "strict");
372 else if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
)
375 seq_puts(s
, "loose");
379 cifs_show_nls(struct seq_file
*s
, struct nls_table
*cur
)
381 struct nls_table
*def
;
383 /* Display iocharset= option if it's not default charset */
384 def
= load_nls_default();
386 seq_printf(s
, ",iocharset=%s", cur
->charset
);
391 * cifs_show_options() is for displaying mount options in /proc/mounts.
392 * Not all settable options are displayed but most of the important
396 cifs_show_options(struct seq_file
*s
, struct dentry
*root
)
398 struct cifs_sb_info
*cifs_sb
= CIFS_SB(root
->d_sb
);
399 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
400 struct sockaddr
*srcaddr
;
401 srcaddr
= (struct sockaddr
*)&tcon
->ses
->server
->srcaddr
;
403 seq_show_option(s
, "vers", tcon
->ses
->server
->vals
->version_string
);
404 cifs_show_security(s
, tcon
->ses
);
405 cifs_show_cache_flavor(s
, cifs_sb
);
407 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
)
408 seq_puts(s
, ",multiuser");
409 else if (tcon
->ses
->user_name
)
410 seq_show_option(s
, "username", tcon
->ses
->user_name
);
412 if (tcon
->ses
->domainName
)
413 seq_show_option(s
, "domain", tcon
->ses
->domainName
);
415 if (srcaddr
->sa_family
!= AF_UNSPEC
) {
416 struct sockaddr_in
*saddr4
;
417 struct sockaddr_in6
*saddr6
;
418 saddr4
= (struct sockaddr_in
*)srcaddr
;
419 saddr6
= (struct sockaddr_in6
*)srcaddr
;
420 if (srcaddr
->sa_family
== AF_INET6
)
421 seq_printf(s
, ",srcaddr=%pI6c",
423 else if (srcaddr
->sa_family
== AF_INET
)
424 seq_printf(s
, ",srcaddr=%pI4",
425 &saddr4
->sin_addr
.s_addr
);
427 seq_printf(s
, ",srcaddr=BAD-AF:%i",
428 (int)(srcaddr
->sa_family
));
431 seq_printf(s
, ",uid=%u",
432 from_kuid_munged(&init_user_ns
, cifs_sb
->mnt_uid
));
433 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_UID
)
434 seq_puts(s
, ",forceuid");
436 seq_puts(s
, ",noforceuid");
438 seq_printf(s
, ",gid=%u",
439 from_kgid_munged(&init_user_ns
, cifs_sb
->mnt_gid
));
440 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_GID
)
441 seq_puts(s
, ",forcegid");
443 seq_puts(s
, ",noforcegid");
445 cifs_show_address(s
, tcon
->ses
->server
);
448 seq_printf(s
, ",file_mode=0%ho,dir_mode=0%ho",
449 cifs_sb
->mnt_file_mode
,
450 cifs_sb
->mnt_dir_mode
);
452 cifs_show_nls(s
, cifs_sb
->local_nls
);
455 seq_puts(s
, ",seal");
457 seq_puts(s
, ",nocase");
459 seq_puts(s
, ",hard");
460 if (tcon
->use_persistent
)
461 seq_puts(s
, ",persistenthandles");
462 else if (tcon
->use_resilient
)
463 seq_puts(s
, ",resilienthandles");
465 seq_puts(s
, ",unix");
467 seq_puts(s
, ",nounix");
468 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
)
469 seq_puts(s
, ",posixpaths");
470 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
)
471 seq_puts(s
, ",setuids");
472 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
)
473 seq_puts(s
, ",serverino");
474 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
475 seq_puts(s
, ",rwpidforward");
476 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
)
477 seq_puts(s
, ",forcemand");
478 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_XATTR
)
479 seq_puts(s
, ",nouser_xattr");
480 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
)
481 seq_puts(s
, ",mapchars");
482 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SFM_CHR
)
483 seq_puts(s
, ",mapposix");
484 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
)
486 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
487 seq_puts(s
, ",nobrl");
488 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
)
489 seq_puts(s
, ",cifsacl");
490 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)
491 seq_puts(s
, ",dynperm");
492 if (root
->d_sb
->s_flags
& MS_POSIXACL
)
494 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MF_SYMLINKS
)
495 seq_puts(s
, ",mfsymlinks");
496 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_FSCACHE
)
498 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOSSYNC
)
499 seq_puts(s
, ",nostrictsync");
500 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
)
501 seq_puts(s
, ",noperm");
502 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_BACKUPUID
)
503 seq_printf(s
, ",backupuid=%u",
504 from_kuid_munged(&init_user_ns
,
505 cifs_sb
->mnt_backupuid
));
506 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_BACKUPGID
)
507 seq_printf(s
, ",backupgid=%u",
508 from_kgid_munged(&init_user_ns
,
509 cifs_sb
->mnt_backupgid
));
511 seq_printf(s
, ",rsize=%u", cifs_sb
->rsize
);
512 seq_printf(s
, ",wsize=%u", cifs_sb
->wsize
);
513 seq_printf(s
, ",echo_interval=%lu",
514 tcon
->ses
->server
->echo_interval
/ HZ
);
515 /* convert actimeo and display it in seconds */
516 seq_printf(s
, ",actimeo=%lu", cifs_sb
->actimeo
/ HZ
);
521 static void cifs_umount_begin(struct super_block
*sb
)
523 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
524 struct cifs_tcon
*tcon
;
529 tcon
= cifs_sb_master_tcon(cifs_sb
);
531 spin_lock(&cifs_tcp_ses_lock
);
532 if ((tcon
->tc_count
> 1) || (tcon
->tidStatus
== CifsExiting
)) {
533 /* we have other mounts to same share or we have
534 already tried to force umount this and woken up
535 all waiting network requests, nothing to do */
536 spin_unlock(&cifs_tcp_ses_lock
);
538 } else if (tcon
->tc_count
== 1)
539 tcon
->tidStatus
= CifsExiting
;
540 spin_unlock(&cifs_tcp_ses_lock
);
542 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
543 /* cancel_notify_requests(tcon); */
544 if (tcon
->ses
&& tcon
->ses
->server
) {
545 cifs_dbg(FYI
, "wake up tasks now - umount begin not complete\n");
546 wake_up_all(&tcon
->ses
->server
->request_q
);
547 wake_up_all(&tcon
->ses
->server
->response_q
);
548 msleep(1); /* yield */
549 /* we have to kick the requests once more */
550 wake_up_all(&tcon
->ses
->server
->response_q
);
557 #ifdef CONFIG_CIFS_STATS2
558 static int cifs_show_stats(struct seq_file
*s
, struct dentry
*root
)
565 static int cifs_remount(struct super_block
*sb
, int *flags
, char *data
)
568 *flags
|= MS_NODIRATIME
;
572 static int cifs_drop_inode(struct inode
*inode
)
574 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
576 /* no serverino => unconditional eviction */
577 return !(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) ||
578 generic_drop_inode(inode
);
581 static const struct super_operations cifs_super_ops
= {
582 .statfs
= cifs_statfs
,
583 .alloc_inode
= cifs_alloc_inode
,
584 .destroy_inode
= cifs_destroy_inode
,
585 .drop_inode
= cifs_drop_inode
,
586 .evict_inode
= cifs_evict_inode
,
587 /* .delete_inode = cifs_delete_inode, */ /* Do not need above
588 function unless later we add lazy close of inodes or unless the
589 kernel forgets to call us with the same number of releases (closes)
591 .show_options
= cifs_show_options
,
592 .umount_begin
= cifs_umount_begin
,
593 .remount_fs
= cifs_remount
,
594 #ifdef CONFIG_CIFS_STATS2
595 .show_stats
= cifs_show_stats
,
600 * Get root dentry from superblock according to prefix path mount option.
601 * Return dentry with refcount + 1 on success and NULL otherwise.
603 static struct dentry
*
604 cifs_get_root(struct smb_vol
*vol
, struct super_block
*sb
)
606 struct dentry
*dentry
;
607 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
608 char *full_path
= NULL
;
612 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
)
613 return dget(sb
->s_root
);
615 full_path
= cifs_build_path_to_root(vol
, cifs_sb
,
616 cifs_sb_master_tcon(cifs_sb
));
617 if (full_path
== NULL
)
618 return ERR_PTR(-ENOMEM
);
620 cifs_dbg(FYI
, "Get root dentry for %s\n", full_path
);
622 sep
= CIFS_DIR_SEP(cifs_sb
);
623 dentry
= dget(sb
->s_root
);
627 struct inode
*dir
= d_inode(dentry
);
628 struct dentry
*child
;
632 dentry
= ERR_PTR(-ENOENT
);
635 if (!S_ISDIR(dir
->i_mode
)) {
637 dentry
= ERR_PTR(-ENOTDIR
);
641 /* skip separators */
648 while (*s
&& *s
!= sep
)
651 child
= lookup_one_len_unlocked(p
, dentry
, s
- p
);
654 } while (!IS_ERR(dentry
));
659 static int cifs_set_super(struct super_block
*sb
, void *data
)
661 struct cifs_mnt_data
*mnt_data
= data
;
662 sb
->s_fs_info
= mnt_data
->cifs_sb
;
663 return set_anon_super(sb
, NULL
);
666 static struct dentry
*
667 cifs_do_mount(struct file_system_type
*fs_type
,
668 int flags
, const char *dev_name
, void *data
)
671 struct super_block
*sb
;
672 struct cifs_sb_info
*cifs_sb
;
673 struct smb_vol
*volume_info
;
674 struct cifs_mnt_data mnt_data
;
677 cifs_dbg(FYI
, "Devname: %s flags: %d\n", dev_name
, flags
);
679 volume_info
= cifs_get_volume_info((char *)data
, dev_name
);
680 if (IS_ERR(volume_info
))
681 return ERR_CAST(volume_info
);
683 cifs_sb
= kzalloc(sizeof(struct cifs_sb_info
), GFP_KERNEL
);
684 if (cifs_sb
== NULL
) {
685 root
= ERR_PTR(-ENOMEM
);
689 cifs_sb
->mountdata
= kstrndup(data
, PAGE_SIZE
, GFP_KERNEL
);
690 if (cifs_sb
->mountdata
== NULL
) {
691 root
= ERR_PTR(-ENOMEM
);
695 rc
= cifs_setup_cifs_sb(volume_info
, cifs_sb
);
701 rc
= cifs_mount(cifs_sb
, volume_info
);
703 if (!(flags
& MS_SILENT
))
704 cifs_dbg(VFS
, "cifs_mount failed w/return code = %d\n",
710 mnt_data
.vol
= volume_info
;
711 mnt_data
.cifs_sb
= cifs_sb
;
712 mnt_data
.flags
= flags
;
714 /* BB should we make this contingent on mount parm? */
715 flags
|= MS_NODIRATIME
| MS_NOATIME
;
717 sb
= sget(fs_type
, cifs_match_super
, cifs_set_super
, flags
, &mnt_data
);
720 cifs_umount(cifs_sb
);
725 cifs_dbg(FYI
, "Use existing superblock\n");
726 cifs_umount(cifs_sb
);
728 rc
= cifs_read_super(sb
);
734 sb
->s_flags
|= MS_ACTIVE
;
737 root
= cifs_get_root(volume_info
, sb
);
741 cifs_dbg(FYI
, "dentry root is: %p\n", root
);
745 deactivate_locked_super(sb
);
747 cifs_cleanup_volume_info(volume_info
);
751 kfree(cifs_sb
->prepath
);
752 kfree(cifs_sb
->mountdata
);
755 unload_nls(volume_info
->local_nls
);
760 cifs_loose_read_iter(struct kiocb
*iocb
, struct iov_iter
*iter
)
763 struct inode
*inode
= file_inode(iocb
->ki_filp
);
765 if (iocb
->ki_filp
->f_flags
& O_DIRECT
)
766 return cifs_user_readv(iocb
, iter
);
768 rc
= cifs_revalidate_mapping(inode
);
772 return generic_file_read_iter(iocb
, iter
);
775 static ssize_t
cifs_file_write_iter(struct kiocb
*iocb
, struct iov_iter
*from
)
777 struct inode
*inode
= file_inode(iocb
->ki_filp
);
778 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
782 if (iocb
->ki_filp
->f_flags
& O_DIRECT
) {
783 written
= cifs_user_writev(iocb
, from
);
784 if (written
> 0 && CIFS_CACHE_READ(cinode
)) {
785 cifs_zap_mapping(inode
);
787 "Set no oplock for inode=%p after a write operation\n",
794 written
= cifs_get_writer(cinode
);
798 written
= generic_file_write_iter(iocb
, from
);
800 if (CIFS_CACHE_WRITE(CIFS_I(inode
)))
803 rc
= filemap_fdatawrite(inode
->i_mapping
);
805 cifs_dbg(FYI
, "cifs_file_write_iter: %d rc on %p inode\n",
809 cifs_put_writer(cinode
);
813 static loff_t
cifs_llseek(struct file
*file
, loff_t offset
, int whence
)
816 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
817 * the cached file length
819 if (whence
!= SEEK_SET
&& whence
!= SEEK_CUR
) {
821 struct inode
*inode
= file_inode(file
);
824 * We need to be sure that all dirty pages are written and the
825 * server has the newest file length.
827 if (!CIFS_CACHE_READ(CIFS_I(inode
)) && inode
->i_mapping
&&
828 inode
->i_mapping
->nrpages
!= 0) {
829 rc
= filemap_fdatawait(inode
->i_mapping
);
831 mapping_set_error(inode
->i_mapping
, rc
);
836 * Some applications poll for the file length in this strange
837 * way so we must seek to end on non-oplocked files by
838 * setting the revalidate time to zero.
840 CIFS_I(inode
)->time
= 0;
842 rc
= cifs_revalidate_file_attr(file
);
846 return generic_file_llseek(file
, offset
, whence
);
850 cifs_setlease(struct file
*file
, long arg
, struct file_lock
**lease
, void **priv
)
853 * Note that this is called by vfs setlease with i_lock held to
854 * protect *lease from going away.
856 struct inode
*inode
= file_inode(file
);
857 struct cifsFileInfo
*cfile
= file
->private_data
;
859 if (!(S_ISREG(inode
->i_mode
)))
862 /* Check if file is oplocked if this is request for new lease */
863 if (arg
== F_UNLCK
||
864 ((arg
== F_RDLCK
) && CIFS_CACHE_READ(CIFS_I(inode
))) ||
865 ((arg
== F_WRLCK
) && CIFS_CACHE_WRITE(CIFS_I(inode
))))
866 return generic_setlease(file
, arg
, lease
, priv
);
867 else if (tlink_tcon(cfile
->tlink
)->local_lease
&&
868 !CIFS_CACHE_READ(CIFS_I(inode
)))
870 * If the server claims to support oplock on this file, then we
871 * still need to check oplock even if the local_lease mount
872 * option is set, but there are servers which do not support
873 * oplock for which this mount option may be useful if the user
874 * knows that the file won't be changed on the server by anyone
877 return generic_setlease(file
, arg
, lease
, priv
);
882 struct file_system_type cifs_fs_type
= {
883 .owner
= THIS_MODULE
,
885 .mount
= cifs_do_mount
,
886 .kill_sb
= cifs_kill_sb
,
889 MODULE_ALIAS_FS("cifs");
890 const struct inode_operations cifs_dir_inode_ops
= {
891 .create
= cifs_create
,
892 .atomic_open
= cifs_atomic_open
,
893 .lookup
= cifs_lookup
,
894 .getattr
= cifs_getattr
,
895 .unlink
= cifs_unlink
,
896 .link
= cifs_hardlink
,
899 .rename2
= cifs_rename2
,
900 .permission
= cifs_permission
,
901 .setattr
= cifs_setattr
,
902 .symlink
= cifs_symlink
,
904 .setxattr
= generic_setxattr
,
905 .getxattr
= generic_getxattr
,
906 .listxattr
= cifs_listxattr
,
907 .removexattr
= generic_removexattr
,
910 const struct inode_operations cifs_file_inode_ops
= {
911 .setattr
= cifs_setattr
,
912 .getattr
= cifs_getattr
,
913 .permission
= cifs_permission
,
914 .setxattr
= generic_setxattr
,
915 .getxattr
= generic_getxattr
,
916 .listxattr
= cifs_listxattr
,
917 .removexattr
= generic_removexattr
,
920 const struct inode_operations cifs_symlink_inode_ops
= {
921 .readlink
= generic_readlink
,
922 .get_link
= cifs_get_link
,
923 .permission
= cifs_permission
,
924 .setxattr
= generic_setxattr
,
925 .getxattr
= generic_getxattr
,
926 .listxattr
= cifs_listxattr
,
927 .removexattr
= generic_removexattr
,
930 static int cifs_clone_file_range(struct file
*src_file
, loff_t off
,
931 struct file
*dst_file
, loff_t destoff
, u64 len
)
933 struct inode
*src_inode
= file_inode(src_file
);
934 struct inode
*target_inode
= file_inode(dst_file
);
935 struct cifsFileInfo
*smb_file_src
= src_file
->private_data
;
936 struct cifsFileInfo
*smb_file_target
= dst_file
->private_data
;
937 struct cifs_tcon
*target_tcon
= tlink_tcon(smb_file_target
->tlink
);
941 cifs_dbg(FYI
, "clone range\n");
945 if (!src_file
->private_data
|| !dst_file
->private_data
) {
947 cifs_dbg(VFS
, "missing cifsFileInfo on copy range src file\n");
952 * Note: cifs case is easier than btrfs since server responsible for
953 * checks for proper open modes and file type and if it wants
954 * server could even support copy of range where source = target
956 lock_two_nondirectories(target_inode
, src_inode
);
959 len
= src_inode
->i_size
- off
;
961 cifs_dbg(FYI
, "about to flush pages\n");
962 /* should we flush first and last page first */
963 truncate_inode_pages_range(&target_inode
->i_data
, destoff
,
964 PAGE_ALIGN(destoff
+ len
)-1);
966 if (target_tcon
->ses
->server
->ops
->duplicate_extents
)
967 rc
= target_tcon
->ses
->server
->ops
->duplicate_extents(xid
,
968 smb_file_src
, smb_file_target
, off
, len
, destoff
);
972 /* force revalidate of size and timestamps of target file now
973 that target is updated on the server */
974 CIFS_I(target_inode
)->time
= 0;
975 /* although unlocking in the reverse order from locking is not
976 strictly necessary here it is a little cleaner to be consistent */
977 unlock_two_nondirectories(src_inode
, target_inode
);
983 const struct file_operations cifs_file_ops
= {
984 .read_iter
= cifs_loose_read_iter
,
985 .write_iter
= cifs_file_write_iter
,
987 .release
= cifs_close
,
991 .mmap
= cifs_file_mmap
,
992 .splice_read
= generic_file_splice_read
,
993 .llseek
= cifs_llseek
,
994 .unlocked_ioctl
= cifs_ioctl
,
995 .clone_file_range
= cifs_clone_file_range
,
996 .setlease
= cifs_setlease
,
997 .fallocate
= cifs_fallocate
,
1000 const struct file_operations cifs_file_strict_ops
= {
1001 .read_iter
= cifs_strict_readv
,
1002 .write_iter
= cifs_strict_writev
,
1004 .release
= cifs_close
,
1006 .fsync
= cifs_strict_fsync
,
1007 .flush
= cifs_flush
,
1008 .mmap
= cifs_file_strict_mmap
,
1009 .splice_read
= generic_file_splice_read
,
1010 .llseek
= cifs_llseek
,
1011 .unlocked_ioctl
= cifs_ioctl
,
1012 .clone_file_range
= cifs_clone_file_range
,
1013 .setlease
= cifs_setlease
,
1014 .fallocate
= cifs_fallocate
,
1017 const struct file_operations cifs_file_direct_ops
= {
1018 /* BB reevaluate whether they can be done with directio, no cache */
1019 .read_iter
= cifs_user_readv
,
1020 .write_iter
= cifs_user_writev
,
1022 .release
= cifs_close
,
1024 .fsync
= cifs_fsync
,
1025 .flush
= cifs_flush
,
1026 .mmap
= cifs_file_mmap
,
1027 .splice_read
= generic_file_splice_read
,
1028 .unlocked_ioctl
= cifs_ioctl
,
1029 .clone_file_range
= cifs_clone_file_range
,
1030 .llseek
= cifs_llseek
,
1031 .setlease
= cifs_setlease
,
1032 .fallocate
= cifs_fallocate
,
1035 const struct file_operations cifs_file_nobrl_ops
= {
1036 .read_iter
= cifs_loose_read_iter
,
1037 .write_iter
= cifs_file_write_iter
,
1039 .release
= cifs_close
,
1040 .fsync
= cifs_fsync
,
1041 .flush
= cifs_flush
,
1042 .mmap
= cifs_file_mmap
,
1043 .splice_read
= generic_file_splice_read
,
1044 .llseek
= cifs_llseek
,
1045 .unlocked_ioctl
= cifs_ioctl
,
1046 .clone_file_range
= cifs_clone_file_range
,
1047 .setlease
= cifs_setlease
,
1048 .fallocate
= cifs_fallocate
,
1051 const struct file_operations cifs_file_strict_nobrl_ops
= {
1052 .read_iter
= cifs_strict_readv
,
1053 .write_iter
= cifs_strict_writev
,
1055 .release
= cifs_close
,
1056 .fsync
= cifs_strict_fsync
,
1057 .flush
= cifs_flush
,
1058 .mmap
= cifs_file_strict_mmap
,
1059 .splice_read
= generic_file_splice_read
,
1060 .llseek
= cifs_llseek
,
1061 .unlocked_ioctl
= cifs_ioctl
,
1062 .clone_file_range
= cifs_clone_file_range
,
1063 .setlease
= cifs_setlease
,
1064 .fallocate
= cifs_fallocate
,
1067 const struct file_operations cifs_file_direct_nobrl_ops
= {
1068 /* BB reevaluate whether they can be done with directio, no cache */
1069 .read_iter
= cifs_user_readv
,
1070 .write_iter
= cifs_user_writev
,
1072 .release
= cifs_close
,
1073 .fsync
= cifs_fsync
,
1074 .flush
= cifs_flush
,
1075 .mmap
= cifs_file_mmap
,
1076 .splice_read
= generic_file_splice_read
,
1077 .unlocked_ioctl
= cifs_ioctl
,
1078 .clone_file_range
= cifs_clone_file_range
,
1079 .llseek
= cifs_llseek
,
1080 .setlease
= cifs_setlease
,
1081 .fallocate
= cifs_fallocate
,
1084 const struct file_operations cifs_dir_ops
= {
1085 .iterate_shared
= cifs_readdir
,
1086 .release
= cifs_closedir
,
1087 .read
= generic_read_dir
,
1088 .unlocked_ioctl
= cifs_ioctl
,
1089 .clone_file_range
= cifs_clone_file_range
,
1090 .llseek
= generic_file_llseek
,
1094 cifs_init_once(void *inode
)
1096 struct cifsInodeInfo
*cifsi
= inode
;
1098 inode_init_once(&cifsi
->vfs_inode
);
1099 init_rwsem(&cifsi
->lock_sem
);
1103 cifs_init_inodecache(void)
1105 cifs_inode_cachep
= kmem_cache_create("cifs_inode_cache",
1106 sizeof(struct cifsInodeInfo
),
1107 0, (SLAB_RECLAIM_ACCOUNT
|
1108 SLAB_MEM_SPREAD
|SLAB_ACCOUNT
),
1110 if (cifs_inode_cachep
== NULL
)
1117 cifs_destroy_inodecache(void)
1120 * Make sure all delayed rcu free inodes are flushed before we
1124 kmem_cache_destroy(cifs_inode_cachep
);
1128 cifs_init_request_bufs(void)
1130 size_t max_hdr_size
= MAX_CIFS_HDR_SIZE
;
1131 #ifdef CONFIG_CIFS_SMB2
1133 * SMB2 maximum header size is bigger than CIFS one - no problems to
1134 * allocate some more bytes for CIFS.
1136 max_hdr_size
= MAX_SMB2_HDR_SIZE
;
1138 if (CIFSMaxBufSize
< 8192) {
1139 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1140 Unicode path name has to fit in any SMB/CIFS path based frames */
1141 CIFSMaxBufSize
= 8192;
1142 } else if (CIFSMaxBufSize
> 1024*127) {
1143 CIFSMaxBufSize
= 1024 * 127;
1145 CIFSMaxBufSize
&= 0x1FE00; /* Round size to even 512 byte mult*/
1148 cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1149 CIFSMaxBufSize, CIFSMaxBufSize);
1151 cifs_req_cachep
= kmem_cache_create("cifs_request",
1152 CIFSMaxBufSize
+ max_hdr_size
, 0,
1153 SLAB_HWCACHE_ALIGN
, NULL
);
1154 if (cifs_req_cachep
== NULL
)
1157 if (cifs_min_rcv
< 1)
1159 else if (cifs_min_rcv
> 64) {
1161 cifs_dbg(VFS
, "cifs_min_rcv set to maximum (64)\n");
1164 cifs_req_poolp
= mempool_create_slab_pool(cifs_min_rcv
,
1167 if (cifs_req_poolp
== NULL
) {
1168 kmem_cache_destroy(cifs_req_cachep
);
1171 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1172 almost all handle based requests (but not write response, nor is it
1173 sufficient for path based requests). A smaller size would have
1174 been more efficient (compacting multiple slab items on one 4k page)
1175 for the case in which debug was on, but this larger size allows
1176 more SMBs to use small buffer alloc and is still much more
1177 efficient to alloc 1 per page off the slab compared to 17K (5page)
1178 alloc of large cifs buffers even when page debugging is on */
1179 cifs_sm_req_cachep
= kmem_cache_create("cifs_small_rq",
1180 MAX_CIFS_SMALL_BUFFER_SIZE
, 0, SLAB_HWCACHE_ALIGN
,
1182 if (cifs_sm_req_cachep
== NULL
) {
1183 mempool_destroy(cifs_req_poolp
);
1184 kmem_cache_destroy(cifs_req_cachep
);
1188 if (cifs_min_small
< 2)
1190 else if (cifs_min_small
> 256) {
1191 cifs_min_small
= 256;
1192 cifs_dbg(FYI
, "cifs_min_small set to maximum (256)\n");
1195 cifs_sm_req_poolp
= mempool_create_slab_pool(cifs_min_small
,
1196 cifs_sm_req_cachep
);
1198 if (cifs_sm_req_poolp
== NULL
) {
1199 mempool_destroy(cifs_req_poolp
);
1200 kmem_cache_destroy(cifs_req_cachep
);
1201 kmem_cache_destroy(cifs_sm_req_cachep
);
1209 cifs_destroy_request_bufs(void)
1211 mempool_destroy(cifs_req_poolp
);
1212 kmem_cache_destroy(cifs_req_cachep
);
1213 mempool_destroy(cifs_sm_req_poolp
);
1214 kmem_cache_destroy(cifs_sm_req_cachep
);
1218 cifs_init_mids(void)
1220 cifs_mid_cachep
= kmem_cache_create("cifs_mpx_ids",
1221 sizeof(struct mid_q_entry
), 0,
1222 SLAB_HWCACHE_ALIGN
, NULL
);
1223 if (cifs_mid_cachep
== NULL
)
1226 /* 3 is a reasonable minimum number of simultaneous operations */
1227 cifs_mid_poolp
= mempool_create_slab_pool(3, cifs_mid_cachep
);
1228 if (cifs_mid_poolp
== NULL
) {
1229 kmem_cache_destroy(cifs_mid_cachep
);
1237 cifs_destroy_mids(void)
1239 mempool_destroy(cifs_mid_poolp
);
1240 kmem_cache_destroy(cifs_mid_cachep
);
1248 INIT_LIST_HEAD(&cifs_tcp_ses_list
);
1249 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1250 INIT_LIST_HEAD(&GlobalDnotifyReqList
);
1251 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q
);
1252 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1254 * Initialize Global counters
1256 atomic_set(&sesInfoAllocCount
, 0);
1257 atomic_set(&tconInfoAllocCount
, 0);
1258 atomic_set(&tcpSesAllocCount
, 0);
1259 atomic_set(&tcpSesReconnectCount
, 0);
1260 atomic_set(&tconInfoReconnectCount
, 0);
1262 atomic_set(&bufAllocCount
, 0);
1263 atomic_set(&smBufAllocCount
, 0);
1264 #ifdef CONFIG_CIFS_STATS2
1265 atomic_set(&totBufAllocCount
, 0);
1266 atomic_set(&totSmBufAllocCount
, 0);
1267 #endif /* CONFIG_CIFS_STATS2 */
1269 atomic_set(&midCount
, 0);
1270 GlobalCurrentXid
= 0;
1271 GlobalTotalActiveXid
= 0;
1272 GlobalMaxActiveXid
= 0;
1273 spin_lock_init(&cifs_tcp_ses_lock
);
1274 spin_lock_init(&cifs_file_list_lock
);
1275 spin_lock_init(&GlobalMid_Lock
);
1277 get_random_bytes(&cifs_lock_secret
, sizeof(cifs_lock_secret
));
1279 if (cifs_max_pending
< 2) {
1280 cifs_max_pending
= 2;
1281 cifs_dbg(FYI
, "cifs_max_pending set to min of 2\n");
1282 } else if (cifs_max_pending
> CIFS_MAX_REQ
) {
1283 cifs_max_pending
= CIFS_MAX_REQ
;
1284 cifs_dbg(FYI
, "cifs_max_pending set to max of %u\n",
1288 cifsiod_wq
= alloc_workqueue("cifsiod", WQ_FREEZABLE
|WQ_MEM_RECLAIM
, 0);
1291 goto out_clean_proc
;
1294 rc
= cifs_fscache_register();
1296 goto out_destroy_wq
;
1298 rc
= cifs_init_inodecache();
1300 goto out_unreg_fscache
;
1302 rc
= cifs_init_mids();
1304 goto out_destroy_inodecache
;
1306 rc
= cifs_init_request_bufs();
1308 goto out_destroy_mids
;
1310 #ifdef CONFIG_CIFS_UPCALL
1311 rc
= init_cifs_spnego();
1313 goto out_destroy_request_bufs
;
1314 #endif /* CONFIG_CIFS_UPCALL */
1316 #ifdef CONFIG_CIFS_ACL
1317 rc
= init_cifs_idmap();
1319 goto out_register_key_type
;
1320 #endif /* CONFIG_CIFS_ACL */
1322 rc
= register_filesystem(&cifs_fs_type
);
1324 goto out_init_cifs_idmap
;
1328 out_init_cifs_idmap
:
1329 #ifdef CONFIG_CIFS_ACL
1331 out_register_key_type
:
1333 #ifdef CONFIG_CIFS_UPCALL
1335 out_destroy_request_bufs
:
1337 cifs_destroy_request_bufs();
1339 cifs_destroy_mids();
1340 out_destroy_inodecache
:
1341 cifs_destroy_inodecache();
1343 cifs_fscache_unregister();
1345 destroy_workqueue(cifsiod_wq
);
1354 cifs_dbg(NOISY
, "exit_cifs\n");
1355 unregister_filesystem(&cifs_fs_type
);
1356 cifs_dfs_release_automount_timer();
1357 #ifdef CONFIG_CIFS_ACL
1360 #ifdef CONFIG_CIFS_UPCALL
1361 unregister_key_type(&cifs_spnego_key_type
);
1363 cifs_destroy_request_bufs();
1364 cifs_destroy_mids();
1365 cifs_destroy_inodecache();
1366 cifs_fscache_unregister();
1367 destroy_workqueue(cifsiod_wq
);
1371 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1372 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1374 ("VFS to access servers complying with the SNIA CIFS Specification "
1375 "e.g. Samba and Windows");
1376 MODULE_VERSION(CIFS_VERSION
);
1377 module_init(init_cifs
)
1378 module_exit(exit_cifs
)