]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - fs/cifs/cifsfs.c
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net
[mirror_ubuntu-zesty-kernel.git] / fs / cifs / cifsfs.c
CommitLineData
1da177e4
LT
1/*
2 * fs/cifs/cifsfs.c
3 *
2b280fab 4 * Copyright (C) International Business Machines Corp., 2002,2008
1da177e4
LT
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * Common Internet FileSystem (CIFS) client
8 *
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.
13 *
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.
18 *
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
22 */
23
24/* Note that BB means BUGBUG (ie something to fix eventually) */
25
26#include <linux/module.h>
27#include <linux/fs.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>
6ab16d24 35#include <linux/delay.h>
45af7a0f 36#include <linux/kthread.h>
7dfb7103 37#include <linux/freezer.h>
fec11dd9 38#include <linux/namei.h>
b8c32dbb 39#include <linux/random.h>
3eb9a889 40#include <net/ipv6.h>
1da177e4
LT
41#include "cifsfs.h"
42#include "cifspdu.h"
43#define DECLARE_GLOBALS_HERE
44#include "cifsglob.h"
45#include "cifsproto.h"
46#include "cifs_debug.h"
47#include "cifs_fs_sb.h"
48#include <linux/mm.h>
84a15b93 49#include <linux/key-type.h>
e545937a 50#include "cifs_spnego.h"
f579cf3c 51#include "fscache.h"
3792c173
PS
52#ifdef CONFIG_CIFS_SMB2
53#include "smb2pdu.h"
54#endif
1da177e4 55
1da177e4 56int cifsFYI = 0;
1da177e4 57int traceSMB = 0;
e7504734 58bool enable_oplocks = true;
1da177e4
LT
59unsigned int linuxExtEnabled = 1;
60unsigned int lookupCacheEnabled = 1;
04912d6a 61unsigned int global_secflags = CIFSSEC_DEF;
3979877e 62/* unsigned int ntlmv2_support = 0; */
1da177e4 63unsigned int sign_CIFS_PDUs = 1;
ee9b6d61 64static const struct super_operations cifs_super_ops;
1da177e4 65unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
60654ce0 66module_param(CIFSMaxBufSize, uint, 0);
63135e08
SF
67MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
68 "Default: 16384 Range: 8192 to 130048");
1da177e4 69unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
60654ce0 70module_param(cifs_min_rcv, uint, 0);
63135e08
SF
71MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
72 "1 to 64");
1da177e4 73unsigned int cifs_min_small = 30;
60654ce0 74module_param(cifs_min_small, uint, 0);
63135e08
SF
75MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
76 "Range: 2 to 256");
1da177e4 77unsigned int cifs_max_pending = CIFS_MAX_REQ;
60654ce0 78module_param(cifs_max_pending, uint, 0444);
63135e08 79MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
10b9b98e 80 "Default: 32767 Range: 2 to 32767.");
e7504734 81module_param(enable_oplocks, bool, 0644);
60654ce0 82MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
e7504734 83
1da177e4
LT
84extern mempool_t *cifs_sm_req_poolp;
85extern mempool_t *cifs_req_poolp;
86extern mempool_t *cifs_mid_poolp;
87
da472fc8
JL
88struct workqueue_struct *cifsiod_wq;
89
24261fc2
MG
90/*
91 * Bumps refcount for cifs super block.
92 * Note that it should be only called if a referece to VFS super block is
93 * already held, e.g. in open-type syscalls context. Otherwise it can race with
94 * atomic_dec_and_test in deactivate_locked_super.
95 */
96void
97cifs_sb_active(struct super_block *sb)
98{
99 struct cifs_sb_info *server = CIFS_SB(sb);
100
101 if (atomic_inc_return(&server->active) == 1)
102 atomic_inc(&sb->s_active);
103}
104
105void
106cifs_sb_deactive(struct super_block *sb)
107{
108 struct cifs_sb_info *server = CIFS_SB(sb);
109
110 if (atomic_dec_and_test(&server->active))
111 deactivate_super(sb);
112}
113
1da177e4 114static int
97d1152a 115cifs_read_super(struct super_block *sb)
1da177e4
LT
116{
117 struct inode *inode;
b2e5cd33 118 struct cifs_sb_info *cifs_sb;
2f6c9479 119 struct cifs_tcon *tcon;
1da177e4 120 int rc = 0;
50c2f753 121
b2e5cd33 122 cifs_sb = CIFS_SB(sb);
2f6c9479 123 tcon = cifs_sb_master_tcon(cifs_sb);
1da177e4 124
2c6292ae
AV
125 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
126 sb->s_flags |= MS_POSIXACL;
127
2f6c9479 128 if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
2c6292ae
AV
129 sb->s_maxbytes = MAX_LFS_FILESIZE;
130 else
131 sb->s_maxbytes = MAX_NON_LFS;
132
133 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
134 sb->s_time_gran = 100;
135
1da177e4
LT
136 sb->s_magic = CIFS_MAGIC_NUMBER;
137 sb->s_op = &cifs_super_ops;
8044f7f4 138 sb->s_bdi = &cifs_sb->bdi;
1da177e4
LT
139 sb->s_blocksize = CIFS_MAX_MSGSIZE;
140 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
9b6763e0 141 inode = cifs_root_iget(sb);
1da177e4 142
ce634ab2
DH
143 if (IS_ERR(inode)) {
144 rc = PTR_ERR(inode);
1da177e4
LT
145 goto out_no_root;
146 }
147
2f6c9479 148 if (tcon->nocase)
66ffd113
JL
149 sb->s_d_op = &cifs_ci_dentry_ops;
150 else
151 sb->s_d_op = &cifs_dentry_ops;
152
48fde701 153 sb->s_root = d_make_root(inode);
1da177e4
LT
154 if (!sb->s_root) {
155 rc = -ENOMEM;
156 goto out_no_root;
157 }
50c2f753 158
f3a6a60e 159#ifdef CONFIG_CIFS_NFSD_EXPORT
7521a3c5 160 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
f96637be 161 cifs_dbg(FYI, "export ops supported\n");
7521a3c5
SF
162 sb->s_export_op = &cifs_export_ops;
163 }
f3a6a60e 164#endif /* CONFIG_CIFS_NFSD_EXPORT */
1da177e4
LT
165
166 return 0;
167
168out_no_root:
f96637be 169 cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
1da177e4
LT
170 return rc;
171}
172
6d686175
AV
173static void cifs_kill_sb(struct super_block *sb)
174{
175 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
176 kill_anon_super(sb);
98ab494d 177 cifs_umount(cifs_sb);
1da177e4
LT
178}
179
180static int
726c3342 181cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
1da177e4 182{
726c3342 183 struct super_block *sb = dentry->d_sb;
39da9847 184 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
96daf2b0 185 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
76ec5e33 186 struct TCP_Server_Info *server = tcon->ses->server;
6d5786a3 187 unsigned int xid;
76ec5e33 188 int rc = 0;
1da177e4 189
6d5786a3 190 xid = get_xid();
1da177e4 191
39da9847
SF
192 /*
193 * PATH_MAX may be too long - it would presumably be total path,
194 * but note that some servers (includinng Samba 3) have a shorter
195 * maximum path.
196 *
197 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
198 */
199 buf->f_namelen = PATH_MAX;
1da177e4
LT
200 buf->f_files = 0; /* undefined */
201 buf->f_ffree = 0; /* unlimited */
202
76ec5e33
PS
203 if (server->ops->queryfs)
204 rc = server->ops->queryfs(xid, tcon, buf);
39da9847 205
6d5786a3 206 free_xid(xid);
39da9847 207 return 0;
1da177e4
LT
208}
209
31742c5a
SF
210static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
211{
7119e220 212 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
31742c5a
SF
213 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
214 struct TCP_Server_Info *server = tcon->ses->server;
215
216 if (server->ops->fallocate)
217 return server->ops->fallocate(file, tcon, mode, off, len);
218
219 return -EOPNOTSUPP;
220}
221
10556cb2 222static int cifs_permission(struct inode *inode, int mask)
1da177e4
LT
223{
224 struct cifs_sb_info *cifs_sb;
225
226 cifs_sb = CIFS_SB(inode->i_sb);
227
f696a365
MS
228 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
229 if ((mask & MAY_EXEC) && !execute_ok(inode))
230 return -EACCES;
231 else
232 return 0;
233 } else /* file mode might have been restricted at mount time
50c2f753 234 on the client (above and beyond ACL on servers) for
1da177e4 235 servers which do not support setting and viewing mode bits,
50c2f753 236 so allowing client to check permissions is useful */
2830ba7f 237 return generic_permission(inode, mask);
1da177e4
LT
238}
239
e18b890b
CL
240static struct kmem_cache *cifs_inode_cachep;
241static struct kmem_cache *cifs_req_cachep;
242static struct kmem_cache *cifs_mid_cachep;
e18b890b 243static struct kmem_cache *cifs_sm_req_cachep;
1da177e4
LT
244mempool_t *cifs_sm_req_poolp;
245mempool_t *cifs_req_poolp;
246mempool_t *cifs_mid_poolp;
247
248static struct inode *
249cifs_alloc_inode(struct super_block *sb)
250{
251 struct cifsInodeInfo *cifs_inode;
e94b1766 252 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
1da177e4
LT
253 if (!cifs_inode)
254 return NULL;
255 cifs_inode->cifsAttrs = 0x20; /* default */
1da177e4 256 cifs_inode->time = 0;
b8c32dbb
PS
257 /*
258 * Until the file is open and we have gotten oplock info back from the
259 * server, can not assume caching of file data or metadata.
260 */
c6723628 261 cifs_set_oplock_level(cifs_inode, 0);
aff8d5ca 262 cifs_inode->flags = 0;
c11f1df5
SP
263 spin_lock_init(&cifs_inode->writers_lock);
264 cifs_inode->writers = 0;
1da177e4 265 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
fbec9ab9 266 cifs_inode->server_eof = 0;
20054bd6
JL
267 cifs_inode->uniqueid = 0;
268 cifs_inode->createtime = 0;
42873b0a 269 cifs_inode->epoch = 0;
b8c32dbb
PS
270#ifdef CONFIG_CIFS_SMB2
271 get_random_bytes(cifs_inode->lease_key, SMB2_LEASE_KEY_SIZE);
272#endif
273 /*
274 * Can not set i_flags here - they get immediately overwritten to zero
275 * by the VFS.
276 */
277 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
1da177e4 278 INIT_LIST_HEAD(&cifs_inode->openFileList);
f45d3416 279 INIT_LIST_HEAD(&cifs_inode->llist);
1da177e4
LT
280 return &cifs_inode->vfs_inode;
281}
282
fa0d7e3d
NP
283static void cifs_i_callback(struct rcu_head *head)
284{
285 struct inode *inode = container_of(head, struct inode, i_rcu);
fa0d7e3d
NP
286 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
287}
288
1da177e4
LT
289static void
290cifs_destroy_inode(struct inode *inode)
291{
fa0d7e3d 292 call_rcu(&inode->i_rcu, cifs_i_callback);
1da177e4
LT
293}
294
9451a9a5 295static void
b57922d9 296cifs_evict_inode(struct inode *inode)
9451a9a5 297{
91b0abe3 298 truncate_inode_pages_final(&inode->i_data);
dbd5768f 299 clear_inode(inode);
9451a9a5
SJ
300 cifs_fscache_release_inode_cookie(inode);
301}
302
61f98ffd
JL
303static void
304cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
305{
a9f1b85e
PS
306 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
307 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
308
571d5972 309 seq_puts(s, ",addr=");
61f98ffd 310
a9f1b85e 311 switch (server->dstaddr.ss_family) {
61f98ffd 312 case AF_INET:
a9f1b85e 313 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
61f98ffd
JL
314 break;
315 case AF_INET6:
a9f1b85e
PS
316 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
317 if (sa6->sin6_scope_id)
318 seq_printf(s, "%%%u", sa6->sin6_scope_id);
61f98ffd
JL
319 break;
320 default:
571d5972 321 seq_puts(s, "(unknown)");
61f98ffd
JL
322 }
323}
324
3e715513 325static void
28e11bd8 326cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
3e715513 327{
eda2116f
SF
328 if (ses->sectype == Unspecified) {
329 if (ses->user_name == NULL)
330 seq_puts(s, ",sec=none");
28e11bd8 331 return;
eda2116f 332 }
28e11bd8 333
571d5972 334 seq_puts(s, ",sec=");
3e715513 335
28e11bd8 336 switch (ses->sectype) {
3e715513 337 case LANMAN:
571d5972 338 seq_puts(s, "lanman");
3e715513
JL
339 break;
340 case NTLMv2:
571d5972 341 seq_puts(s, "ntlmv2");
3e715513
JL
342 break;
343 case NTLM:
571d5972 344 seq_puts(s, "ntlm");
3e715513
JL
345 break;
346 case Kerberos:
571d5972 347 seq_puts(s, "krb5");
3e715513
JL
348 break;
349 case RawNTLMSSP:
571d5972 350 seq_puts(s, "ntlmssp");
3e715513
JL
351 break;
352 default:
353 /* shouldn't ever happen */
571d5972 354 seq_puts(s, "unknown");
3e715513
JL
355 break;
356 }
357
28e11bd8 358 if (ses->sign)
571d5972 359 seq_puts(s, "i");
3e715513
JL
360}
361
d06b5056
JL
362static void
363cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
364{
571d5972 365 seq_puts(s, ",cache=");
d06b5056
JL
366
367 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
571d5972 368 seq_puts(s, "strict");
d06b5056 369 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
571d5972 370 seq_puts(s, "none");
d06b5056 371 else
571d5972 372 seq_puts(s, "loose");
d06b5056
JL
373}
374
3ae35cde
JL
375static void
376cifs_show_nls(struct seq_file *s, struct nls_table *cur)
377{
378 struct nls_table *def;
379
380 /* Display iocharset= option if it's not default charset */
381 def = load_nls_default();
382 if (def != cur)
383 seq_printf(s, ",iocharset=%s", cur->charset);
384 unload_nls(def);
385}
386
1da177e4
LT
387/*
388 * cifs_show_options() is for displaying mount options in /proc/mounts.
389 * Not all settable options are displayed but most of the important
390 * ones are.
391 */
392static int
34c80b1d 393cifs_show_options(struct seq_file *s, struct dentry *root)
1da177e4 394{
34c80b1d 395 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
96daf2b0 396 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
3eb9a889
BG
397 struct sockaddr *srcaddr;
398 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
8616e0fc 399
a068acf2 400 seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
28e11bd8 401 cifs_show_security(s, tcon->ses);
d06b5056 402 cifs_show_cache_flavor(s, cifs_sb);
3e715513 403
29e07c82 404 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
571d5972 405 seq_puts(s, ",multiuser");
8727c8a8 406 else if (tcon->ses->user_name)
a068acf2 407 seq_show_option(s, "username", tcon->ses->user_name);
29e07c82 408
8616e0fc 409 if (tcon->ses->domainName)
a068acf2 410 seq_show_option(s, "domain", tcon->ses->domainName);
8616e0fc 411
3eb9a889
BG
412 if (srcaddr->sa_family != AF_UNSPEC) {
413 struct sockaddr_in *saddr4;
414 struct sockaddr_in6 *saddr6;
415 saddr4 = (struct sockaddr_in *)srcaddr;
416 saddr6 = (struct sockaddr_in6 *)srcaddr;
417 if (srcaddr->sa_family == AF_INET6)
418 seq_printf(s, ",srcaddr=%pI6c",
419 &saddr6->sin6_addr);
420 else if (srcaddr->sa_family == AF_INET)
421 seq_printf(s, ",srcaddr=%pI4",
422 &saddr4->sin_addr.s_addr);
423 else
424 seq_printf(s, ",srcaddr=BAD-AF:%i",
425 (int)(srcaddr->sa_family));
426 }
427
1f68233c
EB
428 seq_printf(s, ",uid=%u",
429 from_kuid_munged(&init_user_ns, cifs_sb->mnt_uid));
340481a3 430 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
571d5972 431 seq_puts(s, ",forceuid");
4486d6ed 432 else
571d5972 433 seq_puts(s, ",noforceuid");
340481a3 434
1f68233c
EB
435 seq_printf(s, ",gid=%u",
436 from_kgid_munged(&init_user_ns, cifs_sb->mnt_gid));
340481a3 437 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
571d5972 438 seq_puts(s, ",forcegid");
4486d6ed 439 else
571d5972 440 seq_puts(s, ",noforcegid");
8616e0fc 441
61f98ffd 442 cifs_show_address(s, tcon->ses->server);
1da177e4 443
8616e0fc 444 if (!tcon->unix_ext)
5206efd6 445 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
2b280fab
SF
446 cifs_sb->mnt_file_mode,
447 cifs_sb->mnt_dir_mode);
3ae35cde
JL
448
449 cifs_show_nls(s, cifs_sb->local_nls);
450
8616e0fc 451 if (tcon->seal)
571d5972 452 seq_puts(s, ",seal");
8616e0fc 453 if (tcon->nocase)
571d5972 454 seq_puts(s, ",nocase");
8616e0fc 455 if (tcon->retry)
571d5972 456 seq_puts(s, ",hard");
f16dfa7c
SF
457 if (tcon->use_persistent)
458 seq_puts(s, ",persistenthandles");
592fafe6
SF
459 else if (tcon->use_resilient)
460 seq_puts(s, ",resilienthandles");
d4ffff1f 461 if (tcon->unix_ext)
571d5972 462 seq_puts(s, ",unix");
d4ffff1f 463 else
571d5972 464 seq_puts(s, ",nounix");
8616e0fc 465 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
571d5972 466 seq_puts(s, ",posixpaths");
8616e0fc 467 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
571d5972 468 seq_puts(s, ",setuids");
8616e0fc 469 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
571d5972 470 seq_puts(s, ",serverino");
d4ffff1f 471 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
571d5972 472 seq_puts(s, ",rwpidforward");
d4ffff1f 473 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
571d5972 474 seq_puts(s, ",forcemand");
8616e0fc 475 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
571d5972 476 seq_puts(s, ",nouser_xattr");
8616e0fc 477 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
571d5972 478 seq_puts(s, ",mapchars");
bc8ebdc4
NA
479 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
480 seq_puts(s, ",mapposix");
8616e0fc 481 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
571d5972 482 seq_puts(s, ",sfu");
8616e0fc 483 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
571d5972 484 seq_puts(s, ",nobrl");
8616e0fc 485 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
571d5972 486 seq_puts(s, ",cifsacl");
8616e0fc 487 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
571d5972 488 seq_puts(s, ",dynperm");
34c80b1d 489 if (root->d_sb->s_flags & MS_POSIXACL)
571d5972 490 seq_puts(s, ",acl");
736a3320 491 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
571d5972 492 seq_puts(s, ",mfsymlinks");
476428f8 493 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
571d5972 494 seq_puts(s, ",fsc");
71c424ba 495 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
571d5972 496 seq_puts(s, ",nostrictsync");
71c424ba 497 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
571d5972 498 seq_puts(s, ",noperm");
3c7c87fd 499 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
1f68233c
EB
500 seq_printf(s, ",backupuid=%u",
501 from_kuid_munged(&init_user_ns,
502 cifs_sb->mnt_backupuid));
3c7c87fd 503 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
1f68233c
EB
504 seq_printf(s, ",backupgid=%u",
505 from_kgid_munged(&init_user_ns,
506 cifs_sb->mnt_backupgid));
8616e0fc 507
28f88810
SP
508 seq_printf(s, ",rsize=%u", cifs_sb->rsize);
509 seq_printf(s, ",wsize=%u", cifs_sb->wsize);
adfeb3e0
SF
510 seq_printf(s, ",echo_interval=%lu",
511 tcon->ses->server->echo_interval / HZ);
6d20e840 512 /* convert actimeo and display it in seconds */
156d1790 513 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
8616e0fc 514
1da177e4
LT
515 return 0;
516}
517
42faad99 518static void cifs_umount_begin(struct super_block *sb)
68058e75 519{
42faad99 520 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
96daf2b0 521 struct cifs_tcon *tcon;
68058e75 522
4523cc30 523 if (cifs_sb == NULL)
9e2e85f8
SF
524 return;
525
0d424ad0 526 tcon = cifs_sb_master_tcon(cifs_sb);
f1987b44 527
3f9bcca7 528 spin_lock(&cifs_tcp_ses_lock);
ad8034f1
SF
529 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
530 /* we have other mounts to same share or we have
531 already tried to force umount this and woken up
532 all waiting network requests, nothing to do */
3f9bcca7 533 spin_unlock(&cifs_tcp_ses_lock);
ad8034f1
SF
534 return;
535 } else if (tcon->tc_count == 1)
5e1253b5 536 tcon->tidStatus = CifsExiting;
3f9bcca7 537 spin_unlock(&cifs_tcp_ses_lock);
5e1253b5 538
3a5ff61c 539 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
7b7abfe3 540 /* cancel_notify_requests(tcon); */
50c2f753 541 if (tcon->ses && tcon->ses->server) {
f96637be 542 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
9e2e85f8 543 wake_up_all(&tcon->ses->server->request_q);
6ab16d24
SF
544 wake_up_all(&tcon->ses->server->response_q);
545 msleep(1); /* yield */
546 /* we have to kick the requests once more */
547 wake_up_all(&tcon->ses->server->response_q);
548 msleep(1);
5e1253b5 549 }
68058e75
SF
550
551 return;
552}
68058e75 553
bf97d287 554#ifdef CONFIG_CIFS_STATS2
64132379 555static int cifs_show_stats(struct seq_file *s, struct dentry *root)
bf97d287
SF
556{
557 /* BB FIXME */
558 return 0;
559}
560#endif
561
1da177e4
LT
562static int cifs_remount(struct super_block *sb, int *flags, char *data)
563{
02b9984d 564 sync_filesystem(sb);
1da177e4
LT
565 *flags |= MS_NODIRATIME;
566 return 0;
567}
568
45321ac5 569static int cifs_drop_inode(struct inode *inode)
12420ac3
JL
570{
571 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
572
45321ac5
AV
573 /* no serverino => unconditional eviction */
574 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
575 generic_drop_inode(inode);
12420ac3
JL
576}
577
ee9b6d61 578static const struct super_operations cifs_super_ops = {
1da177e4
LT
579 .statfs = cifs_statfs,
580 .alloc_inode = cifs_alloc_inode,
581 .destroy_inode = cifs_destroy_inode,
12420ac3 582 .drop_inode = cifs_drop_inode,
b57922d9 583 .evict_inode = cifs_evict_inode,
12420ac3
JL
584/* .delete_inode = cifs_delete_inode, */ /* Do not need above
585 function unless later we add lazy close of inodes or unless the
50c2f753
SF
586 kernel forgets to call us with the same number of releases (closes)
587 as opens */
1da177e4 588 .show_options = cifs_show_options,
7b7abfe3 589 .umount_begin = cifs_umount_begin,
1da177e4 590 .remount_fs = cifs_remount,
bf97d287 591#ifdef CONFIG_CIFS_STATS2
f46d3e11 592 .show_stats = cifs_show_stats,
bf97d287 593#endif
1da177e4
LT
594};
595
f87d39d9
SF
596/*
597 * Get root dentry from superblock according to prefix path mount option.
598 * Return dentry with refcount + 1 on success and NULL otherwise.
599 */
600static struct dentry *
601cifs_get_root(struct smb_vol *vol, struct super_block *sb)
602{
fec11dd9 603 struct dentry *dentry;
f87d39d9 604 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
fec11dd9
AV
605 char *full_path = NULL;
606 char *s, *p;
f87d39d9
SF
607 char sep;
608
6d3ea7e4
SF
609 full_path = cifs_build_path_to_root(vol, cifs_sb,
610 cifs_sb_master_tcon(cifs_sb));
f87d39d9 611 if (full_path == NULL)
9403c9c5 612 return ERR_PTR(-ENOMEM);
f87d39d9 613
f96637be 614 cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
f87d39d9 615
f87d39d9 616 sep = CIFS_DIR_SEP(cifs_sb);
fec11dd9
AV
617 dentry = dget(sb->s_root);
618 p = s = full_path;
619
620 do {
2b0143b5 621 struct inode *dir = d_inode(dentry);
fec11dd9
AV
622 struct dentry *child;
623
5b980b01
PS
624 if (!dir) {
625 dput(dentry);
626 dentry = ERR_PTR(-ENOENT);
627 break;
628 }
ce2ac521
JL
629 if (!S_ISDIR(dir->i_mode)) {
630 dput(dentry);
631 dentry = ERR_PTR(-ENOTDIR);
632 break;
633 }
5b980b01 634
fec11dd9
AV
635 /* skip separators */
636 while (*s == sep)
637 s++;
638 if (!*s)
639 break;
640 p = s++;
641 /* next separator */
642 while (*s && *s != sep)
643 s++;
644
5955102c 645 inode_lock(dir);
fec11dd9 646 child = lookup_one_len(p, dentry, s - p);
5955102c 647 inode_unlock(dir);
fec11dd9
AV
648 dput(dentry);
649 dentry = child;
650 } while (!IS_ERR(dentry));
f87d39d9 651 kfree(full_path);
fec11dd9 652 return dentry;
f87d39d9
SF
653}
654
ee01a14d
AV
655static int cifs_set_super(struct super_block *sb, void *data)
656{
657 struct cifs_mnt_data *mnt_data = data;
658 sb->s_fs_info = mnt_data->cifs_sb;
659 return set_anon_super(sb, NULL);
660}
661
d753ed97
AV
662static struct dentry *
663cifs_do_mount(struct file_system_type *fs_type,
724d9f1c 664 int flags, const char *dev_name, void *data)
1da177e4
LT
665{
666 int rc;
db719222 667 struct super_block *sb;
724d9f1c
PS
668 struct cifs_sb_info *cifs_sb;
669 struct smb_vol *volume_info;
25c7f41e 670 struct cifs_mnt_data mnt_data;
724d9f1c 671 struct dentry *root;
1da177e4 672
f96637be 673 cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
1da177e4 674
04db79b0
JL
675 volume_info = cifs_get_volume_info((char *)data, dev_name);
676 if (IS_ERR(volume_info))
677 return ERR_CAST(volume_info);
724d9f1c
PS
678
679 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
680 if (cifs_sb == NULL) {
681 root = ERR_PTR(-ENOMEM);
5c4f1ad7 682 goto out_nls;
724d9f1c
PS
683 }
684
5d3bc605
AV
685 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
686 if (cifs_sb->mountdata == NULL) {
687 root = ERR_PTR(-ENOMEM);
5c4f1ad7 688 goto out_cifs_sb;
5d3bc605
AV
689 }
690
724d9f1c
PS
691 cifs_setup_cifs_sb(volume_info, cifs_sb);
692
97d1152a
AV
693 rc = cifs_mount(cifs_sb, volume_info);
694 if (rc) {
695 if (!(flags & MS_SILENT))
f96637be
JP
696 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
697 rc);
97d1152a 698 root = ERR_PTR(rc);
5c4f1ad7 699 goto out_mountdata;
97d1152a
AV
700 }
701
25c7f41e
PS
702 mnt_data.vol = volume_info;
703 mnt_data.cifs_sb = cifs_sb;
704 mnt_data.flags = flags;
705
9249e17f
DH
706 /* BB should we make this contingent on mount parm? */
707 flags |= MS_NODIRATIME | MS_NOATIME;
708
709 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
724d9f1c 710 if (IS_ERR(sb)) {
724d9f1c 711 root = ERR_CAST(sb);
97d1152a 712 cifs_umount(cifs_sb);
d757d71b 713 goto out;
724d9f1c 714 }
1da177e4 715
ee01a14d 716 if (sb->s_root) {
f96637be 717 cifs_dbg(FYI, "Use existing superblock\n");
97d1152a 718 cifs_umount(cifs_sb);
5c4f1ad7 719 } else {
5c4f1ad7
AV
720 rc = cifs_read_super(sb);
721 if (rc) {
722 root = ERR_PTR(rc);
723 goto out_super;
724 }
b2e5cd33 725
5c4f1ad7 726 sb->s_flags |= MS_ACTIVE;
1da177e4 727 }
724d9f1c 728
f87d39d9 729 root = cifs_get_root(volume_info, sb);
9403c9c5 730 if (IS_ERR(root))
f87d39d9 731 goto out_super;
25c7f41e 732
f96637be 733 cifs_dbg(FYI, "dentry root is: %p\n", root);
641a58d6 734 goto out;
724d9f1c 735
641a58d6 736out_super:
641a58d6 737 deactivate_locked_super(sb);
641a58d6 738out:
f9e59bcb 739 cifs_cleanup_volume_info(volume_info);
724d9f1c 740 return root;
5c4f1ad7
AV
741
742out_mountdata:
743 kfree(cifs_sb->mountdata);
744out_cifs_sb:
745 kfree(cifs_sb);
746out_nls:
747 unload_nls(volume_info->local_nls);
748 goto out;
1da177e4
LT
749}
750
08bc0353
JL
751static ssize_t
752cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
753{
754 ssize_t rc;
755 struct inode *inode = file_inode(iocb->ki_filp);
756
882137c4
RL
757 if (iocb->ki_filp->f_flags & O_DIRECT)
758 return cifs_user_readv(iocb, iter);
759
08bc0353
JL
760 rc = cifs_revalidate_mapping(inode);
761 if (rc)
762 return rc;
763
764 return generic_file_read_iter(iocb, iter);
765}
766
3dae8750 767static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
1da177e4 768{
496ad9aa 769 struct inode *inode = file_inode(iocb->ki_filp);
c11f1df5 770 struct cifsInodeInfo *cinode = CIFS_I(inode);
1da177e4 771 ssize_t written;
72432ffc 772 int rc;
1da177e4 773
882137c4
RL
774 if (iocb->ki_filp->f_flags & O_DIRECT) {
775 written = cifs_user_writev(iocb, from);
776 if (written > 0 && CIFS_CACHE_READ(cinode)) {
777 cifs_zap_mapping(inode);
778 cifs_dbg(FYI,
779 "Set no oplock for inode=%p after a write operation\n",
780 inode);
781 cinode->oplock = 0;
782 }
783 return written;
784 }
785
c11f1df5
SP
786 written = cifs_get_writer(cinode);
787 if (written)
788 return written;
789
3dae8750 790 written = generic_file_write_iter(iocb, from);
72432ffc 791
18cceb6a 792 if (CIFS_CACHE_WRITE(CIFS_I(inode)))
c11f1df5 793 goto out;
72432ffc
PS
794
795 rc = filemap_fdatawrite(inode->i_mapping);
796 if (rc)
3dae8750 797 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
f96637be 798 rc, inode);
72432ffc 799
c11f1df5
SP
800out:
801 cifs_put_writer(cinode);
1da177e4
LT
802 return written;
803}
804
965c8e59 805static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
c32a0b68 806{
06222e49 807 /*
965c8e59 808 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
06222e49
JB
809 * the cached file length
810 */
965c8e59 811 if (whence != SEEK_SET && whence != SEEK_CUR) {
6feb9891 812 int rc;
496ad9aa 813 struct inode *inode = file_inode(file);
6feb9891
PS
814
815 /*
816 * We need to be sure that all dirty pages are written and the
817 * server has the newest file length.
818 */
18cceb6a 819 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
6feb9891
PS
820 inode->i_mapping->nrpages != 0) {
821 rc = filemap_fdatawait(inode->i_mapping);
156ecb2d
SF
822 if (rc) {
823 mapping_set_error(inode->i_mapping, rc);
824 return rc;
825 }
6feb9891
PS
826 }
827 /*
828 * Some applications poll for the file length in this strange
829 * way so we must seek to end on non-oplocked files by
830 * setting the revalidate time to zero.
831 */
832 CIFS_I(inode)->time = 0;
833
834 rc = cifs_revalidate_file_attr(file);
835 if (rc < 0)
836 return (loff_t)rc;
c32a0b68 837 }
965c8e59 838 return generic_file_llseek(file, offset, whence);
c32a0b68
SF
839}
840
e6f5c789
JL
841static int
842cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
84210e91 843{
18cceb6a
PS
844 /*
845 * Note that this is called by vfs setlease with i_lock held to
846 * protect *lease from going away.
847 */
496ad9aa 848 struct inode *inode = file_inode(file);
ba00ba64 849 struct cifsFileInfo *cfile = file->private_data;
84210e91
SF
850
851 if (!(S_ISREG(inode->i_mode)))
852 return -EINVAL;
853
02440806
JL
854 /* Check if file is oplocked if this is request for new lease */
855 if (arg == F_UNLCK ||
856 ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
18cceb6a 857 ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
e6f5c789 858 return generic_setlease(file, arg, lease, priv);
13cfb733 859 else if (tlink_tcon(cfile->tlink)->local_lease &&
18cceb6a
PS
860 !CIFS_CACHE_READ(CIFS_I(inode)))
861 /*
862 * If the server claims to support oplock on this file, then we
863 * still need to check oplock even if the local_lease mount
864 * option is set, but there are servers which do not support
865 * oplock for which this mount option may be useful if the user
866 * knows that the file won't be changed on the server by anyone
867 * else.
868 */
e6f5c789 869 return generic_setlease(file, arg, lease, priv);
51ee4b84 870 else
84210e91
SF
871 return -EAGAIN;
872}
84210e91 873
e6ab1582 874struct file_system_type cifs_fs_type = {
1da177e4
LT
875 .owner = THIS_MODULE,
876 .name = "cifs",
d753ed97 877 .mount = cifs_do_mount,
6d686175 878 .kill_sb = cifs_kill_sb,
1da177e4
LT
879 /* .fs_flags */
880};
3e64fe5b 881MODULE_ALIAS_FS("cifs");
754661f1 882const struct inode_operations cifs_dir_inode_ops = {
1da177e4 883 .create = cifs_create,
d2c12719 884 .atomic_open = cifs_atomic_open,
1da177e4
LT
885 .lookup = cifs_lookup,
886 .getattr = cifs_getattr,
887 .unlink = cifs_unlink,
888 .link = cifs_hardlink,
889 .mkdir = cifs_mkdir,
890 .rmdir = cifs_rmdir,
7c33d597 891 .rename2 = cifs_rename2,
1da177e4
LT
892 .permission = cifs_permission,
893/* revalidate:cifs_revalidate, */
894 .setattr = cifs_setattr,
895 .symlink = cifs_symlink,
896 .mknod = cifs_mknod,
897#ifdef CONFIG_CIFS_XATTR
898 .setxattr = cifs_setxattr,
899 .getxattr = cifs_getxattr,
900 .listxattr = cifs_listxattr,
901 .removexattr = cifs_removexattr,
902#endif
903};
904
754661f1 905const struct inode_operations cifs_file_inode_ops = {
1da177e4
LT
906/* revalidate:cifs_revalidate, */
907 .setattr = cifs_setattr,
908 .getattr = cifs_getattr, /* do we need this anymore? */
1da177e4
LT
909 .permission = cifs_permission,
910#ifdef CONFIG_CIFS_XATTR
911 .setxattr = cifs_setxattr,
912 .getxattr = cifs_getxattr,
913 .listxattr = cifs_listxattr,
914 .removexattr = cifs_removexattr,
50c2f753 915#endif
1da177e4
LT
916};
917
754661f1 918const struct inode_operations cifs_symlink_inode_ops = {
50c2f753 919 .readlink = generic_readlink,
6b255391 920 .get_link = cifs_get_link,
1da177e4
LT
921 .permission = cifs_permission,
922 /* BB add the following two eventually */
923 /* revalidate: cifs_revalidate,
924 setattr: cifs_notify_change, *//* BB do we need notify change */
925#ifdef CONFIG_CIFS_XATTR
926 .setxattr = cifs_setxattr,
927 .getxattr = cifs_getxattr,
928 .listxattr = cifs_listxattr,
929 .removexattr = cifs_removexattr,
50c2f753 930#endif
1da177e4
LT
931};
932
04b38d60
CH
933static int cifs_clone_file_range(struct file *src_file, loff_t off,
934 struct file *dst_file, loff_t destoff, u64 len)
935{
936 struct inode *src_inode = file_inode(src_file);
937 struct inode *target_inode = file_inode(dst_file);
938 struct cifsFileInfo *smb_file_src = src_file->private_data;
939 struct cifsFileInfo *smb_file_target = dst_file->private_data;
04b38d60
CH
940 struct cifs_tcon *target_tcon = tlink_tcon(smb_file_target->tlink);
941 unsigned int xid;
942 int rc;
943
944 cifs_dbg(FYI, "clone range\n");
945
946 xid = get_xid();
947
948 if (!src_file->private_data || !dst_file->private_data) {
949 rc = -EBADF;
950 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
951 goto out;
952 }
953
954 /*
955 * Note: cifs case is easier than btrfs since server responsible for
956 * checks for proper open modes and file type and if it wants
957 * server could even support copy of range where source = target
958 */
959 lock_two_nondirectories(target_inode, src_inode);
960
961 if (len == 0)
962 len = src_inode->i_size - off;
963
964 cifs_dbg(FYI, "about to flush pages\n");
965 /* should we flush first and last page first */
966 truncate_inode_pages_range(&target_inode->i_data, destoff,
967 PAGE_CACHE_ALIGN(destoff + len)-1);
968
969 if (target_tcon->ses->server->ops->duplicate_extents)
970 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
971 smb_file_src, smb_file_target, off, len, destoff);
972 else
973 rc = -EOPNOTSUPP;
974
975 /* force revalidate of size and timestamps of target file now
976 that target is updated on the server */
977 CIFS_I(target_inode)->time = 0;
04b38d60
CH
978 /* although unlocking in the reverse order from locking is not
979 strictly necessary here it is a little cleaner to be consistent */
980 unlock_two_nondirectories(src_inode, target_inode);
981out:
982 free_xid(xid);
983 return rc;
984}
985
4b6f5d20 986const struct file_operations cifs_file_ops = {
08bc0353 987 .read_iter = cifs_loose_read_iter,
3dae8750 988 .write_iter = cifs_file_write_iter,
1da177e4
LT
989 .open = cifs_open,
990 .release = cifs_close,
991 .lock = cifs_lock,
992 .fsync = cifs_fsync,
993 .flush = cifs_flush,
994 .mmap = cifs_file_mmap,
5ffc4ef4 995 .splice_read = generic_file_splice_read,
c32a0b68 996 .llseek = cifs_llseek,
f9ddcca4 997 .unlocked_ioctl = cifs_ioctl,
04b38d60 998 .clone_file_range = cifs_clone_file_range,
84210e91 999 .setlease = cifs_setlease,
31742c5a 1000 .fallocate = cifs_fallocate,
1da177e4
LT
1001};
1002
8be7e6ba 1003const struct file_operations cifs_file_strict_ops = {
e6a7bcb4 1004 .read_iter = cifs_strict_readv,
3dae8750 1005 .write_iter = cifs_strict_writev,
8be7e6ba
PS
1006 .open = cifs_open,
1007 .release = cifs_close,
1008 .lock = cifs_lock,
1009 .fsync = cifs_strict_fsync,
1010 .flush = cifs_flush,
7a6a19b1 1011 .mmap = cifs_file_strict_mmap,
8be7e6ba
PS
1012 .splice_read = generic_file_splice_read,
1013 .llseek = cifs_llseek,
8be7e6ba 1014 .unlocked_ioctl = cifs_ioctl,
04b38d60 1015 .clone_file_range = cifs_clone_file_range,
8be7e6ba 1016 .setlease = cifs_setlease,
31742c5a 1017 .fallocate = cifs_fallocate,
8be7e6ba
PS
1018};
1019
4b6f5d20 1020const struct file_operations cifs_file_direct_ops = {
0b81c1c4 1021 /* BB reevaluate whether they can be done with directio, no cache */
e6a7bcb4 1022 .read_iter = cifs_user_readv,
3dae8750 1023 .write_iter = cifs_user_writev,
1da177e4
LT
1024 .open = cifs_open,
1025 .release = cifs_close,
1026 .lock = cifs_lock,
1027 .fsync = cifs_fsync,
1028 .flush = cifs_flush,
a994b8fa 1029 .mmap = cifs_file_mmap,
5ffc4ef4 1030 .splice_read = generic_file_splice_read,
f9ddcca4 1031 .unlocked_ioctl = cifs_ioctl,
04b38d60 1032 .clone_file_range = cifs_clone_file_range,
c32a0b68 1033 .llseek = cifs_llseek,
84210e91 1034 .setlease = cifs_setlease,
31742c5a 1035 .fallocate = cifs_fallocate,
1da177e4 1036};
8be7e6ba 1037
4b6f5d20 1038const struct file_operations cifs_file_nobrl_ops = {
08bc0353 1039 .read_iter = cifs_loose_read_iter,
3dae8750 1040 .write_iter = cifs_file_write_iter,
87c89dd7
SF
1041 .open = cifs_open,
1042 .release = cifs_close,
1043 .fsync = cifs_fsync,
1044 .flush = cifs_flush,
1045 .mmap = cifs_file_mmap,
5ffc4ef4 1046 .splice_read = generic_file_splice_read,
c32a0b68 1047 .llseek = cifs_llseek,
f9ddcca4 1048 .unlocked_ioctl = cifs_ioctl,
04b38d60 1049 .clone_file_range = cifs_clone_file_range,
84210e91 1050 .setlease = cifs_setlease,
31742c5a 1051 .fallocate = cifs_fallocate,
8b94bcb9
SF
1052};
1053
8be7e6ba 1054const struct file_operations cifs_file_strict_nobrl_ops = {
e6a7bcb4 1055 .read_iter = cifs_strict_readv,
3dae8750 1056 .write_iter = cifs_strict_writev,
8be7e6ba
PS
1057 .open = cifs_open,
1058 .release = cifs_close,
1059 .fsync = cifs_strict_fsync,
1060 .flush = cifs_flush,
7a6a19b1 1061 .mmap = cifs_file_strict_mmap,
8be7e6ba
PS
1062 .splice_read = generic_file_splice_read,
1063 .llseek = cifs_llseek,
8be7e6ba 1064 .unlocked_ioctl = cifs_ioctl,
04b38d60 1065 .clone_file_range = cifs_clone_file_range,
8be7e6ba 1066 .setlease = cifs_setlease,
31742c5a 1067 .fallocate = cifs_fallocate,
8be7e6ba
PS
1068};
1069
4b6f5d20 1070const struct file_operations cifs_file_direct_nobrl_ops = {
0b81c1c4 1071 /* BB reevaluate whether they can be done with directio, no cache */
e6a7bcb4 1072 .read_iter = cifs_user_readv,
3dae8750 1073 .write_iter = cifs_user_writev,
87c89dd7
SF
1074 .open = cifs_open,
1075 .release = cifs_close,
1076 .fsync = cifs_fsync,
1077 .flush = cifs_flush,
810627a0 1078 .mmap = cifs_file_mmap,
5ffc4ef4 1079 .splice_read = generic_file_splice_read,
f9ddcca4 1080 .unlocked_ioctl = cifs_ioctl,
04b38d60 1081 .clone_file_range = cifs_clone_file_range,
c32a0b68 1082 .llseek = cifs_llseek,
84210e91 1083 .setlease = cifs_setlease,
31742c5a 1084 .fallocate = cifs_fallocate,
8b94bcb9 1085};
1da177e4 1086
4b6f5d20 1087const struct file_operations cifs_dir_ops = {
be4ccdcc 1088 .iterate = cifs_readdir,
1da177e4
LT
1089 .release = cifs_closedir,
1090 .read = generic_read_dir,
f9ddcca4 1091 .unlocked_ioctl = cifs_ioctl,
04b38d60 1092 .clone_file_range = cifs_clone_file_range,
3222a3e5 1093 .llseek = generic_file_llseek,
1da177e4
LT
1094};
1095
1096static void
51cc5068 1097cifs_init_once(void *inode)
1da177e4
LT
1098{
1099 struct cifsInodeInfo *cifsi = inode;
1100
a35afb83 1101 inode_init_once(&cifsi->vfs_inode);
1b4b55a1 1102 init_rwsem(&cifsi->lock_sem);
1da177e4
LT
1103}
1104
9ee108b2 1105static int __init
1da177e4
LT
1106cifs_init_inodecache(void)
1107{
1108 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
26f57364 1109 sizeof(struct cifsInodeInfo),
fffb60f9 1110 0, (SLAB_RECLAIM_ACCOUNT|
5d097056 1111 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
20c2df83 1112 cifs_init_once);
1da177e4
LT
1113 if (cifs_inode_cachep == NULL)
1114 return -ENOMEM;
1115
1116 return 0;
1117}
1118
1119static void
1120cifs_destroy_inodecache(void)
1121{
8c0a8537
KS
1122 /*
1123 * Make sure all delayed rcu free inodes are flushed before we
1124 * destroy cache.
1125 */
1126 rcu_barrier();
1a1d92c1 1127 kmem_cache_destroy(cifs_inode_cachep);
1da177e4
LT
1128}
1129
1130static int
1131cifs_init_request_bufs(void)
1132{
3792c173
PS
1133 size_t max_hdr_size = MAX_CIFS_HDR_SIZE;
1134#ifdef CONFIG_CIFS_SMB2
1135 /*
1136 * SMB2 maximum header size is bigger than CIFS one - no problems to
1137 * allocate some more bytes for CIFS.
1138 */
1139 max_hdr_size = MAX_SMB2_HDR_SIZE;
1140#endif
4523cc30 1141 if (CIFSMaxBufSize < 8192) {
1da177e4
LT
1142 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1143 Unicode path name has to fit in any SMB/CIFS path based frames */
1144 CIFSMaxBufSize = 8192;
1145 } else if (CIFSMaxBufSize > 1024*127) {
1146 CIFSMaxBufSize = 1024 * 127;
1147 } else {
1148 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1149 }
f96637be
JP
1150/*
1151 cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1152 CIFSMaxBufSize, CIFSMaxBufSize);
1153*/
1da177e4 1154 cifs_req_cachep = kmem_cache_create("cifs_request",
3792c173 1155 CIFSMaxBufSize + max_hdr_size, 0,
20c2df83 1156 SLAB_HWCACHE_ALIGN, NULL);
1da177e4
LT
1157 if (cifs_req_cachep == NULL)
1158 return -ENOMEM;
1159
4523cc30 1160 if (cifs_min_rcv < 1)
1da177e4
LT
1161 cifs_min_rcv = 1;
1162 else if (cifs_min_rcv > 64) {
1163 cifs_min_rcv = 64;
f96637be 1164 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1da177e4
LT
1165 }
1166
93d2341c
MD
1167 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1168 cifs_req_cachep);
1da177e4 1169
4523cc30 1170 if (cifs_req_poolp == NULL) {
1da177e4
LT
1171 kmem_cache_destroy(cifs_req_cachep);
1172 return -ENOMEM;
1173 }
ec637e3f 1174 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1da177e4
LT
1175 almost all handle based requests (but not write response, nor is it
1176 sufficient for path based requests). A smaller size would have
50c2f753 1177 been more efficient (compacting multiple slab items on one 4k page)
1da177e4
LT
1178 for the case in which debug was on, but this larger size allows
1179 more SMBs to use small buffer alloc and is still much more
6dc0f87e 1180 efficient to alloc 1 per page off the slab compared to 17K (5page)
1da177e4
LT
1181 alloc of large cifs buffers even when page debugging is on */
1182 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
6dc0f87e 1183 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
20c2df83 1184 NULL);
1da177e4
LT
1185 if (cifs_sm_req_cachep == NULL) {
1186 mempool_destroy(cifs_req_poolp);
1187 kmem_cache_destroy(cifs_req_cachep);
6dc0f87e 1188 return -ENOMEM;
1da177e4
LT
1189 }
1190
4523cc30 1191 if (cifs_min_small < 2)
1da177e4
LT
1192 cifs_min_small = 2;
1193 else if (cifs_min_small > 256) {
1194 cifs_min_small = 256;
f96637be 1195 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1da177e4
LT
1196 }
1197
93d2341c
MD
1198 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1199 cifs_sm_req_cachep);
1da177e4 1200
4523cc30 1201 if (cifs_sm_req_poolp == NULL) {
1da177e4
LT
1202 mempool_destroy(cifs_req_poolp);
1203 kmem_cache_destroy(cifs_req_cachep);
1204 kmem_cache_destroy(cifs_sm_req_cachep);
1205 return -ENOMEM;
1206 }
1207
1208 return 0;
1209}
1210
1211static void
1212cifs_destroy_request_bufs(void)
1213{
1214 mempool_destroy(cifs_req_poolp);
1a1d92c1 1215 kmem_cache_destroy(cifs_req_cachep);
1da177e4 1216 mempool_destroy(cifs_sm_req_poolp);
1a1d92c1 1217 kmem_cache_destroy(cifs_sm_req_cachep);
1da177e4
LT
1218}
1219
1220static int
1221cifs_init_mids(void)
1222{
1223 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
26f57364
SF
1224 sizeof(struct mid_q_entry), 0,
1225 SLAB_HWCACHE_ALIGN, NULL);
1da177e4
LT
1226 if (cifs_mid_cachep == NULL)
1227 return -ENOMEM;
1228
93d2341c
MD
1229 /* 3 is a reasonable minimum number of simultaneous operations */
1230 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
4523cc30 1231 if (cifs_mid_poolp == NULL) {
1da177e4
LT
1232 kmem_cache_destroy(cifs_mid_cachep);
1233 return -ENOMEM;
1234 }
1235
1da177e4
LT
1236 return 0;
1237}
1238
1239static void
1240cifs_destroy_mids(void)
1241{
1242 mempool_destroy(cifs_mid_poolp);
1a1d92c1 1243 kmem_cache_destroy(cifs_mid_cachep);
1da177e4
LT
1244}
1245
1da177e4
LT
1246static int __init
1247init_cifs(void)
1248{
1249 int rc = 0;
1da177e4 1250 cifs_proc_init();
e7ddee90 1251 INIT_LIST_HEAD(&cifs_tcp_ses_list);
0eff0e26 1252#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
4ca9c190
SF
1253 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1254 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
0eff0e26 1255#endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1da177e4
LT
1256/*
1257 * Initialize Global counters
1258 */
1259 atomic_set(&sesInfoAllocCount, 0);
1260 atomic_set(&tconInfoAllocCount, 0);
6dc0f87e 1261 atomic_set(&tcpSesAllocCount, 0);
1da177e4
LT
1262 atomic_set(&tcpSesReconnectCount, 0);
1263 atomic_set(&tconInfoReconnectCount, 0);
1264
1265 atomic_set(&bufAllocCount, 0);
4498eed5
SF
1266 atomic_set(&smBufAllocCount, 0);
1267#ifdef CONFIG_CIFS_STATS2
1268 atomic_set(&totBufAllocCount, 0);
1269 atomic_set(&totSmBufAllocCount, 0);
1270#endif /* CONFIG_CIFS_STATS2 */
1271
1da177e4
LT
1272 atomic_set(&midCount, 0);
1273 GlobalCurrentXid = 0;
1274 GlobalTotalActiveXid = 0;
1275 GlobalMaxActiveXid = 0;
3f9bcca7 1276 spin_lock_init(&cifs_tcp_ses_lock);
4477288a 1277 spin_lock_init(&cifs_file_list_lock);
1da177e4
LT
1278 spin_lock_init(&GlobalMid_Lock);
1279
4523cc30 1280 if (cifs_max_pending < 2) {
1da177e4 1281 cifs_max_pending = 2;
f96637be 1282 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
10b9b98e
PS
1283 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1284 cifs_max_pending = CIFS_MAX_REQ;
f96637be
JP
1285 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1286 CIFS_MAX_REQ);
1da177e4
LT
1287 }
1288
da472fc8
JL
1289 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1290 if (!cifsiod_wq) {
1291 rc = -ENOMEM;
1292 goto out_clean_proc;
1293 }
1294
f579cf3c
SJ
1295 rc = cifs_fscache_register();
1296 if (rc)
da472fc8 1297 goto out_destroy_wq;
f579cf3c 1298
1da177e4 1299 rc = cifs_init_inodecache();
45af7a0f 1300 if (rc)
d3bf5221 1301 goto out_unreg_fscache;
45af7a0f
SF
1302
1303 rc = cifs_init_mids();
1304 if (rc)
1305 goto out_destroy_inodecache;
1306
1307 rc = cifs_init_request_bufs();
1308 if (rc)
1309 goto out_destroy_mids;
1310
84a15b93
JL
1311#ifdef CONFIG_CIFS_UPCALL
1312 rc = register_key_type(&cifs_spnego_key_type);
1313 if (rc)
4d79dba0
SP
1314 goto out_destroy_request_bufs;
1315#endif /* CONFIG_CIFS_UPCALL */
1316
1317#ifdef CONFIG_CIFS_ACL
1318 rc = init_cifs_idmap();
1319 if (rc)
c4aca0c0 1320 goto out_register_key_type;
4d79dba0
SP
1321#endif /* CONFIG_CIFS_ACL */
1322
1323 rc = register_filesystem(&cifs_fs_type);
1324 if (rc)
c4aca0c0 1325 goto out_init_cifs_idmap;
45af7a0f 1326
45af7a0f
SF
1327 return 0;
1328
c4aca0c0 1329out_init_cifs_idmap:
4d79dba0
SP
1330#ifdef CONFIG_CIFS_ACL
1331 exit_cifs_idmap();
c4aca0c0 1332out_register_key_type:
4d79dba0 1333#endif
84a15b93 1334#ifdef CONFIG_CIFS_UPCALL
4d79dba0 1335 unregister_key_type(&cifs_spnego_key_type);
c4aca0c0 1336out_destroy_request_bufs:
1fc7995d 1337#endif
45af7a0f 1338 cifs_destroy_request_bufs();
d3bf5221 1339out_destroy_mids:
45af7a0f 1340 cifs_destroy_mids();
d3bf5221 1341out_destroy_inodecache:
45af7a0f 1342 cifs_destroy_inodecache();
d3bf5221 1343out_unreg_fscache:
f579cf3c 1344 cifs_fscache_unregister();
da472fc8
JL
1345out_destroy_wq:
1346 destroy_workqueue(cifsiod_wq);
d3bf5221
SF
1347out_clean_proc:
1348 cifs_proc_clean();
1da177e4
LT
1349 return rc;
1350}
1351
1352static void __exit
1353exit_cifs(void)
1354{
f96637be 1355 cifs_dbg(NOISY, "exit_cifs\n");
3dd93306 1356 unregister_filesystem(&cifs_fs_type);
78d31a3a 1357 cifs_dfs_release_automount_timer();
4d79dba0 1358#ifdef CONFIG_CIFS_ACL
4d79dba0
SP
1359 exit_cifs_idmap();
1360#endif
84a15b93
JL
1361#ifdef CONFIG_CIFS_UPCALL
1362 unregister_key_type(&cifs_spnego_key_type);
1da177e4 1363#endif
1da177e4 1364 cifs_destroy_request_bufs();
3dd93306
JL
1365 cifs_destroy_mids();
1366 cifs_destroy_inodecache();
1367 cifs_fscache_unregister();
da472fc8 1368 destroy_workqueue(cifsiod_wq);
3dd93306 1369 cifs_proc_clean();
1da177e4
LT
1370}
1371
1372MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
6dc0f87e 1373MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1da177e4 1374MODULE_DESCRIPTION
63135e08
SF
1375 ("VFS to access servers complying with the SNIA CIFS Specification "
1376 "e.g. Samba and Windows");
1da177e4
LT
1377MODULE_VERSION(CIFS_VERSION);
1378module_init(init_cifs)
1379module_exit(exit_cifs)