blob: 4bdd547dbf6fb3d10a2b2b962b710b722d0b9685 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/cifsfs.c
3 *
Steve French2b280fa2008-05-17 03:12:45 +00004 * Copyright (C) International Business Machines Corp., 2002,2008
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * 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>
Steve French6ab16d22005-11-29 20:55:11 -080035#include <linux/delay.h>
Steve French45af7a02006-04-21 22:52:25 +000036#include <linux/kthread.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080037#include <linux/freezer.h>
Al Virofec11dd2011-07-18 13:50:40 -040038#include <linux/namei.h>
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -070039#include <linux/random.h>
Ben Greear3eb9a882010-09-01 17:06:02 -070040#include <net/ipv6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#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>
Jeff Layton84a15b92007-11-03 05:02:24 +000049#include <linux/key-type.h>
Jeff Laytone5459372007-11-03 05:11:06 +000050#include "cifs_spnego.h"
Suresh Jayaramanf579cf32010-07-05 18:11:50 +053051#include "fscache.h"
Pavel Shilovsky3792c172012-01-12 22:40:50 +040052#ifdef CONFIG_CIFS_SMB2
53#include "smb2pdu.h"
54#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
Linus Torvalds1da177e2005-04-16 15:20:36 -070056int cifsFYI = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057int traceSMB = 0;
Steve Frenche7504732011-10-12 17:47:03 -050058bool enable_oplocks = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -070059unsigned int linuxExtEnabled = 1;
60unsigned int lookupCacheEnabled = 1;
Jeff Layton04912d62010-04-24 07:57:45 -040061unsigned int global_secflags = CIFSSEC_DEF;
Steve French39798772006-05-31 22:40:51 +000062/* unsigned int ntlmv2_support = 0; */
Linus Torvalds1da177e2005-04-16 15:20:36 -070063unsigned int sign_CIFS_PDUs = 1;
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -080064static const struct super_operations cifs_super_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
Jeff Layton60654ce2012-11-25 08:00:34 -050066module_param(CIFSMaxBufSize, uint, 0);
Steve French63135e02007-07-17 17:34:02 +000067MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
68 "Default: 16384 Range: 8192 to 130048");
Linus Torvalds1da177e2005-04-16 15:20:36 -070069unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
Jeff Layton60654ce2012-11-25 08:00:34 -050070module_param(cifs_min_rcv, uint, 0);
Steve French63135e02007-07-17 17:34:02 +000071MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
72 "1 to 64");
Linus Torvalds1da177e2005-04-16 15:20:36 -070073unsigned int cifs_min_small = 30;
Jeff Layton60654ce2012-11-25 08:00:34 -050074module_param(cifs_min_small, uint, 0);
Steve French63135e02007-07-17 17:34:02 +000075MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
76 "Range: 2 to 256");
Linus Torvalds1da177e2005-04-16 15:20:36 -070077unsigned int cifs_max_pending = CIFS_MAX_REQ;
Jeff Layton60654ce2012-11-25 08:00:34 -050078module_param(cifs_max_pending, uint, 0444);
Steve French63135e02007-07-17 17:34:02 +000079MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
Pavel Shilovsky10b9b982012-03-20 12:55:09 +030080 "Default: 32767 Range: 2 to 32767.");
Steve Frenche7504732011-10-12 17:47:03 -050081module_param(enable_oplocks, bool, 0644);
Jeff Layton60654ce2012-11-25 08:00:34 -050082MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
Steve Frenche7504732011-10-12 17:47:03 -050083
Linus Torvalds1da177e2005-04-16 15:20:36 -070084extern mempool_t *cifs_sm_req_poolp;
85extern mempool_t *cifs_req_poolp;
86extern mempool_t *cifs_mid_poolp;
87
Jeff Laytonda472fc2012-03-23 14:40:53 -040088struct workqueue_struct *cifsiod_wq;
89
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -070090#ifdef CONFIG_CIFS_SMB2
91__u8 cifs_client_guid[SMB2_CLIENT_GUID_SIZE];
92#endif
93
Mateusz Guzik24261fc2013-03-08 16:30:03 +010094/*
95 * Bumps refcount for cifs super block.
96 * Note that it should be only called if a referece to VFS super block is
97 * already held, e.g. in open-type syscalls context. Otherwise it can race with
98 * atomic_dec_and_test in deactivate_locked_super.
99 */
100void
101cifs_sb_active(struct super_block *sb)
102{
103 struct cifs_sb_info *server = CIFS_SB(sb);
104
105 if (atomic_inc_return(&server->active) == 1)
106 atomic_inc(&sb->s_active);
107}
108
109void
110cifs_sb_deactive(struct super_block *sb)
111{
112 struct cifs_sb_info *server = CIFS_SB(sb);
113
114 if (atomic_dec_and_test(&server->active))
115 deactivate_super(sb);
116}
117
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118static int
Al Viro97d11522011-06-17 09:29:57 -0400119cifs_read_super(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120{
121 struct inode *inode;
Pavel Shilovskyb2e5cd32011-05-25 13:35:34 +0400122 struct cifs_sb_info *cifs_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +0000124
Pavel Shilovskyb2e5cd32011-05-25 13:35:34 +0400125 cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126
Al Viro2c6292a2011-06-17 09:05:48 -0400127 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
128 sb->s_flags |= MS_POSIXACL;
129
130 if (cifs_sb_master_tcon(cifs_sb)->ses->capabilities & CAP_LARGE_FILES)
131 sb->s_maxbytes = MAX_LFS_FILESIZE;
132 else
133 sb->s_maxbytes = MAX_NON_LFS;
134
135 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
136 sb->s_time_gran = 100;
137
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 sb->s_magic = CIFS_MAGIC_NUMBER;
139 sb->s_op = &cifs_super_ops;
Jens Axboe8044f7f2010-04-22 12:09:48 +0200140 sb->s_bdi = &cifs_sb->bdi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 sb->s_blocksize = CIFS_MAX_MSGSIZE;
142 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
Shirish Pargaonkar9b6763e2011-02-21 23:56:59 -0600143 inode = cifs_root_iget(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
David Howellsce634ab2008-02-07 00:15:33 -0800145 if (IS_ERR(inode)) {
146 rc = PTR_ERR(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 goto out_no_root;
148 }
149
Al Viro48fde702012-01-08 22:15:13 -0500150 sb->s_root = d_make_root(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 if (!sb->s_root) {
152 rc = -ENOMEM;
153 goto out_no_root;
154 }
Steve French50c2f752007-07-13 00:33:32 +0000155
Sedat Dilekea4b5742012-04-28 14:13:53 +0200156 /* do that *after* d_make_root() - we want NULL ->d_op for root here */
Al Viro1c929cf2010-12-18 11:43:51 -0500157 if (cifs_sb_master_tcon(cifs_sb)->nocase)
158 sb->s_d_op = &cifs_ci_dentry_ops;
159 else
160 sb->s_d_op = &cifs_dentry_ops;
161
Paul Bollef3a6a602011-10-12 14:14:04 +0200162#ifdef CONFIG_CIFS_NFSD_EXPORT
Steve French7521a3c2007-07-11 18:30:34 +0000163 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500164 cifs_dbg(FYI, "export ops supported\n");
Steve French7521a3c2007-07-11 18:30:34 +0000165 sb->s_export_op = &cifs_export_ops;
166 }
Paul Bollef3a6a602011-10-12 14:14:04 +0200167#endif /* CONFIG_CIFS_NFSD_EXPORT */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
169 return 0;
170
171out_no_root:
Joe Perchesf96637b2013-05-04 22:12:25 -0500172 cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 return rc;
174}
175
Al Viro6d686172011-06-17 08:34:57 -0400176static void cifs_kill_sb(struct super_block *sb)
177{
178 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
179 kill_anon_super(sb);
Al Viro98ab4942011-06-17 09:32:10 -0400180 cifs_umount(cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181}
182
183static int
David Howells726c3342006-06-23 02:02:58 -0700184cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185{
David Howells726c3342006-06-23 02:02:58 -0700186 struct super_block *sb = dentry->d_sb;
Steve French39da9842008-04-28 04:04:34 +0000187 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French96daf2b2011-05-27 04:34:02 +0000188 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Pavel Shilovsky76ec5e32012-09-18 16:20:33 -0700189 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400190 unsigned int xid;
Pavel Shilovsky76ec5e32012-09-18 16:20:33 -0700191 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400193 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
Steve French39da9842008-04-28 04:04:34 +0000195 /*
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
198 * maximum path.
199 *
200 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
201 */
202 buf->f_namelen = PATH_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 buf->f_files = 0; /* undefined */
204 buf->f_ffree = 0; /* unlimited */
205
Pavel Shilovsky76ec5e32012-09-18 16:20:33 -0700206 if (server->ops->queryfs)
207 rc = server->ops->queryfs(xid, tcon, buf);
Steve French39da9842008-04-28 04:04:34 +0000208
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400209 free_xid(xid);
Steve French39da9842008-04-28 04:04:34 +0000210 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211}
212
Al Viro10556cb2011-06-20 19:28:19 -0400213static int cifs_permission(struct inode *inode, int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214{
215 struct cifs_sb_info *cifs_sb;
216
217 cifs_sb = CIFS_SB(inode->i_sb);
218
Miklos Szeredif696a362008-07-31 13:41:58 +0200219 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
220 if ((mask & MAY_EXEC) && !execute_ok(inode))
221 return -EACCES;
222 else
223 return 0;
224 } else /* file mode might have been restricted at mount time
Steve French50c2f752007-07-13 00:33:32 +0000225 on the client (above and beyond ACL on servers) for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 servers which do not support setting and viewing mode bits,
Steve French50c2f752007-07-13 00:33:32 +0000227 so allowing client to check permissions is useful */
Al Viro2830ba72011-06-20 19:16:29 -0400228 return generic_permission(inode, mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229}
230
Christoph Lametere18b8902006-12-06 20:33:20 -0800231static struct kmem_cache *cifs_inode_cachep;
232static struct kmem_cache *cifs_req_cachep;
233static struct kmem_cache *cifs_mid_cachep;
Christoph Lametere18b8902006-12-06 20:33:20 -0800234static struct kmem_cache *cifs_sm_req_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235mempool_t *cifs_sm_req_poolp;
236mempool_t *cifs_req_poolp;
237mempool_t *cifs_mid_poolp;
238
239static struct inode *
240cifs_alloc_inode(struct super_block *sb)
241{
242 struct cifsInodeInfo *cifs_inode;
Christoph Lametere94b1762006-12-06 20:33:17 -0800243 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 if (!cifs_inode)
245 return NULL;
246 cifs_inode->cifsAttrs = 0x20; /* default */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 cifs_inode->time = 0;
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700248 /*
249 * Until the file is open and we have gotten oplock info back from the
250 * server, can not assume caching of file data or metadata.
251 */
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300252 cifs_set_oplock_level(cifs_inode, 0);
Jeff Layton9a8165f2008-10-17 21:03:20 -0400253 cifs_inode->delete_pending = false;
Jeff Laytondf2cf172010-02-12 07:44:16 -0500254 cifs_inode->invalid_mapping = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400256 cifs_inode->server_eof = 0;
Jeff Layton20054bd2011-01-07 11:30:27 -0500257 cifs_inode->uniqueid = 0;
258 cifs_inode->createtime = 0;
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700259#ifdef CONFIG_CIFS_SMB2
260 get_random_bytes(cifs_inode->lease_key, SMB2_LEASE_KEY_SIZE);
261#endif
262 /*
263 * Can not set i_flags here - they get immediately overwritten to zero
264 * by the VFS.
265 */
266 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 INIT_LIST_HEAD(&cifs_inode->openFileList);
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700268 INIT_LIST_HEAD(&cifs_inode->llist);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 return &cifs_inode->vfs_inode;
270}
271
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100272static void cifs_i_callback(struct rcu_head *head)
273{
274 struct inode *inode = container_of(head, struct inode, i_rcu);
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100275 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
276}
277
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278static void
279cifs_destroy_inode(struct inode *inode)
280{
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100281 call_rcu(&inode->i_rcu, cifs_i_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282}
283
Jeff Layton61f98ff2009-06-11 10:27:32 -0400284static void
Al Virob57922d2010-06-07 14:34:48 -0400285cifs_evict_inode(struct inode *inode)
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530286{
Al Virob57922d2010-06-07 14:34:48 -0400287 truncate_inode_pages(&inode->i_data, 0);
Jan Karadbd57682012-05-03 14:48:02 +0200288 clear_inode(inode);
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530289 cifs_fscache_release_inode_cookie(inode);
290}
291
292static void
Jeff Layton61f98ff2009-06-11 10:27:32 -0400293cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
294{
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300295 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
296 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
297
Jeff Layton61f98ff2009-06-11 10:27:32 -0400298 seq_printf(s, ",addr=");
299
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300300 switch (server->dstaddr.ss_family) {
Jeff Layton61f98ff2009-06-11 10:27:32 -0400301 case AF_INET:
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300302 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
Jeff Layton61f98ff2009-06-11 10:27:32 -0400303 break;
304 case AF_INET6:
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300305 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
306 if (sa6->sin6_scope_id)
307 seq_printf(s, "%%%u", sa6->sin6_scope_id);
Jeff Layton61f98ff2009-06-11 10:27:32 -0400308 break;
309 default:
310 seq_printf(s, "(unknown)");
311 }
312}
313
Jeff Layton3e715512011-06-13 11:50:41 -0400314static void
Jeff Layton28e11bd2013-05-26 07:01:00 -0400315cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
Jeff Layton3e715512011-06-13 11:50:41 -0400316{
Jeff Layton28e11bd2013-05-26 07:01:00 -0400317 if (ses->sectype == Unspecified)
318 return;
319
Jeff Layton3e715512011-06-13 11:50:41 -0400320 seq_printf(s, ",sec=");
321
Jeff Layton28e11bd2013-05-26 07:01:00 -0400322 switch (ses->sectype) {
Jeff Layton3e715512011-06-13 11:50:41 -0400323 case LANMAN:
324 seq_printf(s, "lanman");
325 break;
326 case NTLMv2:
327 seq_printf(s, "ntlmv2");
328 break;
329 case NTLM:
330 seq_printf(s, "ntlm");
331 break;
332 case Kerberos:
333 seq_printf(s, "krb5");
334 break;
335 case RawNTLMSSP:
336 seq_printf(s, "ntlmssp");
337 break;
338 default:
339 /* shouldn't ever happen */
340 seq_printf(s, "unknown");
341 break;
342 }
343
Jeff Layton28e11bd2013-05-26 07:01:00 -0400344 if (ses->sign)
Jeff Layton3e715512011-06-13 11:50:41 -0400345 seq_printf(s, "i");
346}
347
Jeff Laytond06b5052012-05-16 07:53:01 -0400348static void
349cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
350{
351 seq_printf(s, ",cache=");
352
353 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
354 seq_printf(s, "strict");
355 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
356 seq_printf(s, "none");
357 else
358 seq_printf(s, "loose");
359}
360
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361/*
362 * cifs_show_options() is for displaying mount options in /proc/mounts.
363 * Not all settable options are displayed but most of the important
364 * ones are.
365 */
366static int
Al Viro34c80b12011-12-08 21:32:45 -0500367cifs_show_options(struct seq_file *s, struct dentry *root)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368{
Al Viro34c80b12011-12-08 21:32:45 -0500369 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
Steve French96daf2b2011-05-27 04:34:02 +0000370 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Ben Greear3eb9a882010-09-01 17:06:02 -0700371 struct sockaddr *srcaddr;
372 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
Jeff Layton23db65f2012-05-15 12:20:51 -0400374 seq_printf(s, ",vers=%s", tcon->ses->server->vals->version_string);
Jeff Layton28e11bd2013-05-26 07:01:00 -0400375 cifs_show_security(s, tcon->ses);
Jeff Laytond06b5052012-05-16 07:53:01 -0400376 cifs_show_cache_flavor(s, cifs_sb);
Jeff Layton3e715512011-06-13 11:50:41 -0400377
Jeff Layton29e07c82010-09-29 19:51:12 -0400378 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
379 seq_printf(s, ",multiuser");
Steve French8727c8a2011-02-25 01:11:56 -0600380 else if (tcon->ses->user_name)
381 seq_printf(s, ",username=%s", tcon->ses->user_name);
Jeff Layton29e07c82010-09-29 19:51:12 -0400382
Jeff Layton8616e0f2009-06-11 10:27:28 -0400383 if (tcon->ses->domainName)
384 seq_printf(s, ",domain=%s", tcon->ses->domainName);
385
Ben Greear3eb9a882010-09-01 17:06:02 -0700386 if (srcaddr->sa_family != AF_UNSPEC) {
387 struct sockaddr_in *saddr4;
388 struct sockaddr_in6 *saddr6;
389 saddr4 = (struct sockaddr_in *)srcaddr;
390 saddr6 = (struct sockaddr_in6 *)srcaddr;
391 if (srcaddr->sa_family == AF_INET6)
392 seq_printf(s, ",srcaddr=%pI6c",
393 &saddr6->sin6_addr);
394 else if (srcaddr->sa_family == AF_INET)
395 seq_printf(s, ",srcaddr=%pI4",
396 &saddr4->sin_addr.s_addr);
397 else
398 seq_printf(s, ",srcaddr=BAD-AF:%i",
399 (int)(srcaddr->sa_family));
400 }
401
Eric W. Biederman1f682332013-02-06 01:20:20 -0800402 seq_printf(s, ",uid=%u",
403 from_kuid_munged(&init_user_ns, cifs_sb->mnt_uid));
Jeff Layton340481a32009-06-11 10:27:29 -0400404 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
405 seq_printf(s, ",forceuid");
Jeff Layton4486d6e2009-08-03 12:45:10 -0400406 else
407 seq_printf(s, ",noforceuid");
Jeff Layton340481a32009-06-11 10:27:29 -0400408
Eric W. Biederman1f682332013-02-06 01:20:20 -0800409 seq_printf(s, ",gid=%u",
410 from_kgid_munged(&init_user_ns, cifs_sb->mnt_gid));
Jeff Layton340481a32009-06-11 10:27:29 -0400411 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
412 seq_printf(s, ",forcegid");
Jeff Layton4486d6e2009-08-03 12:45:10 -0400413 else
414 seq_printf(s, ",noforcegid");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400415
Jeff Layton61f98ff2009-06-11 10:27:32 -0400416 cifs_show_address(s, tcon->ses->server);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400417
418 if (!tcon->unix_ext)
Al Viro5206efd2011-07-26 03:22:14 -0400419 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
Steve French2b280fa2008-05-17 03:12:45 +0000420 cifs_sb->mnt_file_mode,
421 cifs_sb->mnt_dir_mode);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400422 if (tcon->seal)
423 seq_printf(s, ",seal");
424 if (tcon->nocase)
425 seq_printf(s, ",nocase");
426 if (tcon->retry)
427 seq_printf(s, ",hard");
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000428 if (tcon->unix_ext)
429 seq_printf(s, ",unix");
430 else
431 seq_printf(s, ",nounix");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400432 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
433 seq_printf(s, ",posixpaths");
434 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
435 seq_printf(s, ",setuids");
436 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
437 seq_printf(s, ",serverino");
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000438 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
439 seq_printf(s, ",rwpidforward");
440 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
441 seq_printf(s, ",forcemand");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400442 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
443 seq_printf(s, ",nouser_xattr");
444 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
445 seq_printf(s, ",mapchars");
446 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
447 seq_printf(s, ",sfu");
448 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
449 seq_printf(s, ",nobrl");
450 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
451 seq_printf(s, ",cifsacl");
452 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
453 seq_printf(s, ",dynperm");
Al Viro34c80b12011-12-08 21:32:45 -0500454 if (root->d_sb->s_flags & MS_POSIXACL)
Jeff Layton8616e0f2009-06-11 10:27:28 -0400455 seq_printf(s, ",acl");
Stefan Metzmacher736a3322010-07-30 14:56:00 +0200456 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
457 seq_printf(s, ",mfsymlinks");
Suresh Jayaraman476428f2010-11-24 17:49:07 +0530458 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
459 seq_printf(s, ",fsc");
Steve French71c424b2011-10-19 20:44:48 -0500460 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
461 seq_printf(s, ",nostrictsync");
462 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
463 seq_printf(s, ",noperm");
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +0100464 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
Eric W. Biederman1f682332013-02-06 01:20:20 -0800465 seq_printf(s, ",backupuid=%u",
466 from_kuid_munged(&init_user_ns,
467 cifs_sb->mnt_backupuid));
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +0100468 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
Eric W. Biederman1f682332013-02-06 01:20:20 -0800469 seq_printf(s, ",backupgid=%u",
470 from_kgid_munged(&init_user_ns,
471 cifs_sb->mnt_backupgid));
Steve French2b280fa2008-05-17 03:12:45 +0000472
Sachin Prabhu28f88812012-04-24 15:28:30 +0100473 seq_printf(s, ",rsize=%u", cifs_sb->rsize);
474 seq_printf(s, ",wsize=%u", cifs_sb->wsize);
Suresh Jayaraman6d20e842010-12-01 14:42:28 +0530475 /* convert actimeo and display it in seconds */
Sachin Prabhu156d1792012-04-25 12:10:14 +0100476 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400477
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 return 0;
479}
480
Al Viro42faad92008-04-24 07:21:56 -0400481static void cifs_umount_begin(struct super_block *sb)
Steve French68058e72005-10-10 10:34:22 -0700482{
Al Viro42faad92008-04-24 07:21:56 -0400483 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French96daf2b2011-05-27 04:34:02 +0000484 struct cifs_tcon *tcon;
Steve French68058e72005-10-10 10:34:22 -0700485
Steve French4523cc32007-04-30 20:13:06 +0000486 if (cifs_sb == NULL)
Steve French9e2e85f2005-10-10 14:28:38 -0700487 return;
488
Jeff Layton0d424ad2010-09-20 16:01:35 -0700489 tcon = cifs_sb_master_tcon(cifs_sb);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500490
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530491 spin_lock(&cifs_tcp_ses_lock);
Steve Frenchad8034f2009-06-26 03:25:49 +0000492 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
493 /* we have other mounts to same share or we have
494 already tried to force umount this and woken up
495 all waiting network requests, nothing to do */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530496 spin_unlock(&cifs_tcp_ses_lock);
Steve Frenchad8034f2009-06-26 03:25:49 +0000497 return;
498 } else if (tcon->tc_count == 1)
Steve French5e1253b2005-10-10 14:06:37 -0700499 tcon->tidStatus = CifsExiting;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530500 spin_unlock(&cifs_tcp_ses_lock);
Steve French5e1253b2005-10-10 14:06:37 -0700501
Steve French3a5ff612006-07-14 22:37:11 +0000502 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
Steve French7b7abfe2005-11-09 15:21:09 -0800503 /* cancel_notify_requests(tcon); */
Steve French50c2f752007-07-13 00:33:32 +0000504 if (tcon->ses && tcon->ses->server) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500505 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
Steve French9e2e85f2005-10-10 14:28:38 -0700506 wake_up_all(&tcon->ses->server->request_q);
Steve French6ab16d22005-11-29 20:55:11 -0800507 wake_up_all(&tcon->ses->server->response_q);
508 msleep(1); /* yield */
509 /* we have to kick the requests once more */
510 wake_up_all(&tcon->ses->server->response_q);
511 msleep(1);
Steve French5e1253b2005-10-10 14:06:37 -0700512 }
Steve French68058e72005-10-10 10:34:22 -0700513
514 return;
515}
Steve French68058e72005-10-10 10:34:22 -0700516
Steve Frenchbf97d282006-09-28 21:34:06 +0000517#ifdef CONFIG_CIFS_STATS2
Al Viro64132372011-12-08 20:51:13 -0500518static int cifs_show_stats(struct seq_file *s, struct dentry *root)
Steve Frenchbf97d282006-09-28 21:34:06 +0000519{
520 /* BB FIXME */
521 return 0;
522}
523#endif
524
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525static int cifs_remount(struct super_block *sb, int *flags, char *data)
526{
527 *flags |= MS_NODIRATIME;
528 return 0;
529}
530
Al Viro45321ac2010-06-07 13:43:19 -0400531static int cifs_drop_inode(struct inode *inode)
Jeff Layton12420ac2010-06-01 14:47:40 -0400532{
533 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
534
Al Viro45321ac2010-06-07 13:43:19 -0400535 /* no serverino => unconditional eviction */
536 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
537 generic_drop_inode(inode);
Jeff Layton12420ac2010-06-01 14:47:40 -0400538}
539
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800540static const struct super_operations cifs_super_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 .statfs = cifs_statfs,
542 .alloc_inode = cifs_alloc_inode,
543 .destroy_inode = cifs_destroy_inode,
Jeff Layton12420ac2010-06-01 14:47:40 -0400544 .drop_inode = cifs_drop_inode,
Al Virob57922d2010-06-07 14:34:48 -0400545 .evict_inode = cifs_evict_inode,
Jeff Layton12420ac2010-06-01 14:47:40 -0400546/* .delete_inode = cifs_delete_inode, */ /* Do not need above
547 function unless later we add lazy close of inodes or unless the
Steve French50c2f752007-07-13 00:33:32 +0000548 kernel forgets to call us with the same number of releases (closes)
549 as opens */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 .show_options = cifs_show_options,
Steve French7b7abfe2005-11-09 15:21:09 -0800551 .umount_begin = cifs_umount_begin,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 .remount_fs = cifs_remount,
Steve Frenchbf97d282006-09-28 21:34:06 +0000553#ifdef CONFIG_CIFS_STATS2
Steve Frenchf46d3e12006-09-30 01:08:55 +0000554 .show_stats = cifs_show_stats,
Steve Frenchbf97d282006-09-28 21:34:06 +0000555#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556};
557
Steve Frenchf87d39d2011-05-27 03:50:55 +0000558/*
559 * Get root dentry from superblock according to prefix path mount option.
560 * Return dentry with refcount + 1 on success and NULL otherwise.
561 */
562static struct dentry *
563cifs_get_root(struct smb_vol *vol, struct super_block *sb)
564{
Al Virofec11dd2011-07-18 13:50:40 -0400565 struct dentry *dentry;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000566 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Al Virofec11dd2011-07-18 13:50:40 -0400567 char *full_path = NULL;
568 char *s, *p;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000569 char sep;
570
Steve French6d3ea7e2012-11-28 22:34:41 -0600571 full_path = cifs_build_path_to_root(vol, cifs_sb,
572 cifs_sb_master_tcon(cifs_sb));
Steve Frenchf87d39d2011-05-27 03:50:55 +0000573 if (full_path == NULL)
Al Viro9403c9c2011-06-17 10:02:59 -0400574 return ERR_PTR(-ENOMEM);
Steve Frenchf87d39d2011-05-27 03:50:55 +0000575
Joe Perchesf96637b2013-05-04 22:12:25 -0500576 cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
Steve Frenchf87d39d2011-05-27 03:50:55 +0000577
Steve Frenchf87d39d2011-05-27 03:50:55 +0000578 sep = CIFS_DIR_SEP(cifs_sb);
Al Virofec11dd2011-07-18 13:50:40 -0400579 dentry = dget(sb->s_root);
580 p = s = full_path;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000581
Al Virofec11dd2011-07-18 13:50:40 -0400582 do {
583 struct inode *dir = dentry->d_inode;
584 struct dentry *child;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000585
Pavel Shilovsky5b980b02011-08-21 19:30:15 +0400586 if (!dir) {
587 dput(dentry);
588 dentry = ERR_PTR(-ENOENT);
589 break;
590 }
Jeff Laytonce2ac522013-02-01 15:11:01 -0500591 if (!S_ISDIR(dir->i_mode)) {
592 dput(dentry);
593 dentry = ERR_PTR(-ENOTDIR);
594 break;
595 }
Pavel Shilovsky5b980b02011-08-21 19:30:15 +0400596
Al Virofec11dd2011-07-18 13:50:40 -0400597 /* skip separators */
598 while (*s == sep)
599 s++;
600 if (!*s)
601 break;
602 p = s++;
603 /* next separator */
604 while (*s && *s != sep)
605 s++;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000606
Al Virofec11dd2011-07-18 13:50:40 -0400607 mutex_lock(&dir->i_mutex);
608 child = lookup_one_len(p, dentry, s - p);
609 mutex_unlock(&dir->i_mutex);
610 dput(dentry);
611 dentry = child;
612 } while (!IS_ERR(dentry));
Steve Frenchf87d39d2011-05-27 03:50:55 +0000613 kfree(full_path);
Al Virofec11dd2011-07-18 13:50:40 -0400614 return dentry;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000615}
616
Al Viroee01a142011-06-17 09:47:23 -0400617static int cifs_set_super(struct super_block *sb, void *data)
618{
619 struct cifs_mnt_data *mnt_data = data;
620 sb->s_fs_info = mnt_data->cifs_sb;
621 return set_anon_super(sb, NULL);
622}
623
Al Virod753ed92010-07-26 12:52:33 +0400624static struct dentry *
625cifs_do_mount(struct file_system_type *fs_type,
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000626 int flags, const char *dev_name, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627{
628 int rc;
Jan Blunckdb719222010-08-15 22:51:10 +0200629 struct super_block *sb;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000630 struct cifs_sb_info *cifs_sb;
631 struct smb_vol *volume_info;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400632 struct cifs_mnt_data mnt_data;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000633 struct dentry *root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634
Joe Perchesf96637b2013-05-04 22:12:25 -0500635 cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636
Jeff Layton04db79b2011-07-06 08:10:38 -0400637 volume_info = cifs_get_volume_info((char *)data, dev_name);
638 if (IS_ERR(volume_info))
639 return ERR_CAST(volume_info);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000640
641 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
642 if (cifs_sb == NULL) {
643 root = ERR_PTR(-ENOMEM);
Al Viro5c4f1ad2011-06-17 09:56:55 -0400644 goto out_nls;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000645 }
646
Al Viro5d3bc602011-06-17 09:17:28 -0400647 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
648 if (cifs_sb->mountdata == NULL) {
649 root = ERR_PTR(-ENOMEM);
Al Viro5c4f1ad2011-06-17 09:56:55 -0400650 goto out_cifs_sb;
Al Viro5d3bc602011-06-17 09:17:28 -0400651 }
652
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000653 cifs_setup_cifs_sb(volume_info, cifs_sb);
654
Al Viro97d11522011-06-17 09:29:57 -0400655 rc = cifs_mount(cifs_sb, volume_info);
656 if (rc) {
657 if (!(flags & MS_SILENT))
Joe Perchesf96637b2013-05-04 22:12:25 -0500658 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
659 rc);
Al Viro97d11522011-06-17 09:29:57 -0400660 root = ERR_PTR(rc);
Al Viro5c4f1ad2011-06-17 09:56:55 -0400661 goto out_mountdata;
Al Viro97d11522011-06-17 09:29:57 -0400662 }
663
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400664 mnt_data.vol = volume_info;
665 mnt_data.cifs_sb = cifs_sb;
666 mnt_data.flags = flags;
667
David Howells9249e172012-06-25 12:55:37 +0100668 /* BB should we make this contingent on mount parm? */
669 flags |= MS_NODIRATIME | MS_NOATIME;
670
671 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000672 if (IS_ERR(sb)) {
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000673 root = ERR_CAST(sb);
Al Viro97d11522011-06-17 09:29:57 -0400674 cifs_umount(cifs_sb);
Al Virod757d712011-06-17 09:42:43 -0400675 goto out;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000676 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
Al Viroee01a142011-06-17 09:47:23 -0400678 if (sb->s_root) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500679 cifs_dbg(FYI, "Use existing superblock\n");
Al Viro97d11522011-06-17 09:29:57 -0400680 cifs_umount(cifs_sb);
Al Viro5c4f1ad2011-06-17 09:56:55 -0400681 } else {
Al Viro5c4f1ad2011-06-17 09:56:55 -0400682 rc = cifs_read_super(sb);
683 if (rc) {
684 root = ERR_PTR(rc);
685 goto out_super;
686 }
687
688 sb->s_flags |= MS_ACTIVE;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400689 }
690
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400691 root = cifs_get_root(volume_info, sb);
Al Viro9403c9c2011-06-17 10:02:59 -0400692 if (IS_ERR(root))
Al Virofa18f1b2011-06-17 09:50:44 -0400693 goto out_super;
Al Virofa18f1b2011-06-17 09:50:44 -0400694
Joe Perchesf96637b2013-05-04 22:12:25 -0500695 cifs_dbg(FYI, "dentry root is: %p\n", root);
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400696 goto out;
697
Pavel Shilovsky641a58d2011-05-26 00:02:16 +0400698out_super:
Pavel Shilovsky641a58d2011-05-26 00:02:16 +0400699 deactivate_locked_super(sb);
Pavel Shilovsky641a58d2011-05-26 00:02:16 +0400700out:
Jeff Laytonf9e59bc2011-07-06 08:10:37 -0400701 cifs_cleanup_volume_info(volume_info);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000702 return root;
Al Viro5c4f1ad2011-06-17 09:56:55 -0400703
704out_mountdata:
705 kfree(cifs_sb->mountdata);
706out_cifs_sb:
707 kfree(cifs_sb);
708out_nls:
709 unload_nls(volume_info->local_nls);
710 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711}
712
Badari Pulavarty027445c2006-09-30 23:28:46 -0700713static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
714 unsigned long nr_segs, loff_t pos)
Steve French87c89dd2005-11-17 17:03:00 -0800715{
Al Viro496ad9a2013-01-23 17:07:38 -0500716 struct inode *inode = file_inode(iocb->ki_filp);
Steve French87c89dd2005-11-17 17:03:00 -0800717 ssize_t written;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500718 int rc;
Steve French87c89dd2005-11-17 17:03:00 -0800719
Badari Pulavarty027445c2006-09-30 23:28:46 -0700720 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500721
722 if (CIFS_I(inode)->clientCanCacheAll)
723 return written;
724
725 rc = filemap_fdatawrite(inode->i_mapping);
726 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500727 cifs_dbg(FYI, "cifs_file_aio_write: %d rc on %p inode\n",
728 rc, inode);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500729
Steve French87c89dd2005-11-17 17:03:00 -0800730 return written;
731}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732
Andrew Morton965c8e52012-12-17 15:59:39 -0800733static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
Steve Frenchc32a0b62006-01-12 14:41:28 -0800734{
Josef Bacik06222e42011-07-18 13:21:38 -0400735 /*
Andrew Morton965c8e52012-12-17 15:59:39 -0800736 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
Josef Bacik06222e42011-07-18 13:21:38 -0400737 * the cached file length
738 */
Andrew Morton965c8e52012-12-17 15:59:39 -0800739 if (whence != SEEK_SET && whence != SEEK_CUR) {
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400740 int rc;
Al Viro496ad9a2013-01-23 17:07:38 -0500741 struct inode *inode = file_inode(file);
Steve French030e9d82007-02-01 04:27:59 +0000742
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400743 /*
744 * We need to be sure that all dirty pages are written and the
745 * server has the newest file length.
746 */
747 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
748 inode->i_mapping->nrpages != 0) {
749 rc = filemap_fdatawait(inode->i_mapping);
Steve French156ecb22011-05-20 17:00:01 +0000750 if (rc) {
751 mapping_set_error(inode->i_mapping, rc);
752 return rc;
753 }
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400754 }
755 /*
756 * Some applications poll for the file length in this strange
757 * way so we must seek to end on non-oplocked files by
758 * setting the revalidate time to zero.
759 */
760 CIFS_I(inode)->time = 0;
Steve French030e9d82007-02-01 04:27:59 +0000761
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400762 rc = cifs_revalidate_file_attr(file);
763 if (rc < 0)
764 return (loff_t)rc;
Steve Frenchc32a0b62006-01-12 14:41:28 -0800765 }
Andrew Morton965c8e52012-12-17 15:59:39 -0800766 return generic_file_llseek(file, offset, whence);
Steve Frenchc32a0b62006-01-12 14:41:28 -0800767}
768
Steve French84210e92008-10-23 04:42:37 +0000769static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
770{
Jeff Layton1c8c6012013-06-21 08:58:15 -0400771 /* note that this is called by vfs setlease with i_lock held
Arnd Bergmannb89f4322010-09-18 15:09:31 +0200772 to protect *lease from going away */
Al Viro496ad9a2013-01-23 17:07:38 -0500773 struct inode *inode = file_inode(file);
Jeff Laytonba00ba62010-09-20 16:01:31 -0700774 struct cifsFileInfo *cfile = file->private_data;
Steve French84210e92008-10-23 04:42:37 +0000775
776 if (!(S_ISREG(inode->i_mode)))
777 return -EINVAL;
778
779 /* check if file is oplocked */
780 if (((arg == F_RDLCK) &&
781 (CIFS_I(inode)->clientCanCacheRead)) ||
782 ((arg == F_WRLCK) &&
783 (CIFS_I(inode)->clientCanCacheAll)))
784 return generic_setlease(file, arg, lease);
Jeff Layton13cfb732010-09-29 19:51:11 -0400785 else if (tlink_tcon(cfile->tlink)->local_lease &&
786 !CIFS_I(inode)->clientCanCacheRead)
Steve French84210e92008-10-23 04:42:37 +0000787 /* If the server claims to support oplock on this
788 file, then we still need to check oplock even
789 if the local_lease mount option is set, but there
790 are servers which do not support oplock for which
791 this mount option may be useful if the user
792 knows that the file won't be changed on the server
793 by anyone else */
794 return generic_setlease(file, arg, lease);
Christoph Hellwig51ee4b82010-10-31 08:35:10 -0400795 else
Steve French84210e92008-10-23 04:42:37 +0000796 return -EAGAIN;
797}
Steve French84210e92008-10-23 04:42:37 +0000798
Igor Mammedove6ab1582008-01-11 01:49:48 +0000799struct file_system_type cifs_fs_type = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 .owner = THIS_MODULE,
801 .name = "cifs",
Al Virod753ed92010-07-26 12:52:33 +0400802 .mount = cifs_do_mount,
Al Viro6d686172011-06-17 08:34:57 -0400803 .kill_sb = cifs_kill_sb,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 /* .fs_flags */
805};
Eric W. Biederman3e64fe52013-03-11 07:05:42 -0700806MODULE_ALIAS_FS("cifs");
Arjan van de Ven754661f2007-02-12 00:55:38 -0800807const struct inode_operations cifs_dir_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 .create = cifs_create,
Miklos Szeredid2c12712012-06-05 15:10:23 +0200809 .atomic_open = cifs_atomic_open,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 .lookup = cifs_lookup,
811 .getattr = cifs_getattr,
812 .unlink = cifs_unlink,
813 .link = cifs_hardlink,
814 .mkdir = cifs_mkdir,
815 .rmdir = cifs_rmdir,
816 .rename = cifs_rename,
817 .permission = cifs_permission,
818/* revalidate:cifs_revalidate, */
819 .setattr = cifs_setattr,
820 .symlink = cifs_symlink,
821 .mknod = cifs_mknod,
822#ifdef CONFIG_CIFS_XATTR
823 .setxattr = cifs_setxattr,
824 .getxattr = cifs_getxattr,
825 .listxattr = cifs_listxattr,
826 .removexattr = cifs_removexattr,
827#endif
828};
829
Arjan van de Ven754661f2007-02-12 00:55:38 -0800830const struct inode_operations cifs_file_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831/* revalidate:cifs_revalidate, */
832 .setattr = cifs_setattr,
833 .getattr = cifs_getattr, /* do we need this anymore? */
834 .rename = cifs_rename,
835 .permission = cifs_permission,
836#ifdef CONFIG_CIFS_XATTR
837 .setxattr = cifs_setxattr,
838 .getxattr = cifs_getxattr,
839 .listxattr = cifs_listxattr,
840 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000841#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842};
843
Arjan van de Ven754661f2007-02-12 00:55:38 -0800844const struct inode_operations cifs_symlink_inode_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000845 .readlink = generic_readlink,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 .follow_link = cifs_follow_link,
847 .put_link = cifs_put_link,
848 .permission = cifs_permission,
849 /* BB add the following two eventually */
850 /* revalidate: cifs_revalidate,
851 setattr: cifs_notify_change, *//* BB do we need notify change */
852#ifdef CONFIG_CIFS_XATTR
853 .setxattr = cifs_setxattr,
854 .getxattr = cifs_getxattr,
855 .listxattr = cifs_listxattr,
856 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000857#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858};
859
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800860const struct file_operations cifs_file_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800861 .read = do_sync_read,
862 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800863 .aio_read = generic_file_aio_read,
864 .aio_write = cifs_file_aio_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 .open = cifs_open,
866 .release = cifs_close,
867 .lock = cifs_lock,
868 .fsync = cifs_fsync,
869 .flush = cifs_flush,
870 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200871 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800872 .llseek = cifs_llseek,
Steve Frenchc67593a2005-04-28 22:41:04 -0700873#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000874 .unlocked_ioctl = cifs_ioctl,
Steve Frenchc67593a2005-04-28 22:41:04 -0700875#endif /* CONFIG_CIFS_POSIX */
Steve French84210e92008-10-23 04:42:37 +0000876 .setlease = cifs_setlease,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877};
878
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300879const struct file_operations cifs_file_strict_ops = {
880 .read = do_sync_read,
881 .write = do_sync_write,
Pavel Shilovskya70307e2010-12-14 11:50:41 +0300882 .aio_read = cifs_strict_readv,
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500883 .aio_write = cifs_strict_writev,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300884 .open = cifs_open,
885 .release = cifs_close,
886 .lock = cifs_lock,
887 .fsync = cifs_strict_fsync,
888 .flush = cifs_flush,
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +0300889 .mmap = cifs_file_strict_mmap,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300890 .splice_read = generic_file_splice_read,
891 .llseek = cifs_llseek,
892#ifdef CONFIG_CIFS_POSIX
893 .unlocked_ioctl = cifs_ioctl,
894#endif /* CONFIG_CIFS_POSIX */
895 .setlease = cifs_setlease,
896};
897
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800898const struct file_operations cifs_file_direct_ops = {
Pavel Shilovsky0b81c1c2011-03-10 10:11:05 +0300899 /* BB reevaluate whether they can be done with directio, no cache */
900 .read = do_sync_read,
901 .write = do_sync_write,
902 .aio_read = cifs_user_readv,
903 .aio_write = cifs_user_writev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 .open = cifs_open,
905 .release = cifs_close,
906 .lock = cifs_lock,
907 .fsync = cifs_fsync,
908 .flush = cifs_flush,
Steve Frencha994b8f2009-12-07 05:44:46 +0000909 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200910 .splice_read = generic_file_splice_read,
Steve Frenchc67593a2005-04-28 22:41:04 -0700911#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000912 .unlocked_ioctl = cifs_ioctl,
Steve Frenchc67593a2005-04-28 22:41:04 -0700913#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800914 .llseek = cifs_llseek,
Steve French84210e92008-10-23 04:42:37 +0000915 .setlease = cifs_setlease,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916};
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300917
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800918const struct file_operations cifs_file_nobrl_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800919 .read = do_sync_read,
920 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800921 .aio_read = generic_file_aio_read,
922 .aio_write = cifs_file_aio_write,
923 .open = cifs_open,
924 .release = cifs_close,
925 .fsync = cifs_fsync,
926 .flush = cifs_flush,
927 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200928 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800929 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800930#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000931 .unlocked_ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800932#endif /* CONFIG_CIFS_POSIX */
Steve French84210e92008-10-23 04:42:37 +0000933 .setlease = cifs_setlease,
Steve French8b94bcb2005-11-11 11:41:00 -0800934};
935
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300936const struct file_operations cifs_file_strict_nobrl_ops = {
937 .read = do_sync_read,
938 .write = do_sync_write,
Pavel Shilovskya70307e2010-12-14 11:50:41 +0300939 .aio_read = cifs_strict_readv,
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500940 .aio_write = cifs_strict_writev,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300941 .open = cifs_open,
942 .release = cifs_close,
943 .fsync = cifs_strict_fsync,
944 .flush = cifs_flush,
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +0300945 .mmap = cifs_file_strict_mmap,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300946 .splice_read = generic_file_splice_read,
947 .llseek = cifs_llseek,
948#ifdef CONFIG_CIFS_POSIX
949 .unlocked_ioctl = cifs_ioctl,
950#endif /* CONFIG_CIFS_POSIX */
951 .setlease = cifs_setlease,
952};
953
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800954const struct file_operations cifs_file_direct_nobrl_ops = {
Pavel Shilovsky0b81c1c2011-03-10 10:11:05 +0300955 /* BB reevaluate whether they can be done with directio, no cache */
956 .read = do_sync_read,
957 .write = do_sync_write,
958 .aio_read = cifs_user_readv,
959 .aio_write = cifs_user_writev,
Steve French87c89dd2005-11-17 17:03:00 -0800960 .open = cifs_open,
961 .release = cifs_close,
962 .fsync = cifs_fsync,
963 .flush = cifs_flush,
Pavel Shilovsky810627a02010-03-27 02:00:49 +0000964 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200965 .splice_read = generic_file_splice_read,
Steve French8b94bcb2005-11-11 11:41:00 -0800966#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000967 .unlocked_ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800968#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800969 .llseek = cifs_llseek,
Steve French84210e92008-10-23 04:42:37 +0000970 .setlease = cifs_setlease,
Steve French8b94bcb2005-11-11 11:41:00 -0800971};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800973const struct file_operations cifs_dir_ops = {
Al Virobe4ccdc2013-05-22 16:17:25 -0400974 .iterate = cifs_readdir,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 .release = cifs_closedir,
976 .read = generic_read_dir,
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000977 .unlocked_ioctl = cifs_ioctl,
Christoph Hellwig3222a3e2008-09-03 21:53:01 +0200978 .llseek = generic_file_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979};
980
981static void
Alexey Dobriyan51cc5062008-07-25 19:45:34 -0700982cifs_init_once(void *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983{
984 struct cifsInodeInfo *cifsi = inode;
985
Christoph Lametera35afb82007-05-16 22:10:57 -0700986 inode_init_once(&cifsi->vfs_inode);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700987 init_rwsem(&cifsi->lock_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988}
989
990static int
991cifs_init_inodecache(void)
992{
993 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
Steve French26f57362007-08-30 22:09:15 +0000994 sizeof(struct cifsInodeInfo),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800995 0, (SLAB_RECLAIM_ACCOUNT|
996 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +0900997 cifs_init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 if (cifs_inode_cachep == NULL)
999 return -ENOMEM;
1000
1001 return 0;
1002}
1003
1004static void
1005cifs_destroy_inodecache(void)
1006{
Kirill A. Shutemov8c0a8532012-09-26 11:33:07 +10001007 /*
1008 * Make sure all delayed rcu free inodes are flushed before we
1009 * destroy cache.
1010 */
1011 rcu_barrier();
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001012 kmem_cache_destroy(cifs_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013}
1014
1015static int
1016cifs_init_request_bufs(void)
1017{
Pavel Shilovsky3792c172012-01-12 22:40:50 +04001018 size_t max_hdr_size = MAX_CIFS_HDR_SIZE;
1019#ifdef CONFIG_CIFS_SMB2
1020 /*
1021 * SMB2 maximum header size is bigger than CIFS one - no problems to
1022 * allocate some more bytes for CIFS.
1023 */
1024 max_hdr_size = MAX_SMB2_HDR_SIZE;
1025#endif
Steve French4523cc32007-04-30 20:13:06 +00001026 if (CIFSMaxBufSize < 8192) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1028 Unicode path name has to fit in any SMB/CIFS path based frames */
1029 CIFSMaxBufSize = 8192;
1030 } else if (CIFSMaxBufSize > 1024*127) {
1031 CIFSMaxBufSize = 1024 * 127;
1032 } else {
1033 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1034 }
Joe Perchesf96637b2013-05-04 22:12:25 -05001035/*
1036 cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1037 CIFSMaxBufSize, CIFSMaxBufSize);
1038*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 cifs_req_cachep = kmem_cache_create("cifs_request",
Pavel Shilovsky3792c172012-01-12 22:40:50 +04001040 CIFSMaxBufSize + max_hdr_size, 0,
Paul Mundt20c2df82007-07-20 10:11:58 +09001041 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 if (cifs_req_cachep == NULL)
1043 return -ENOMEM;
1044
Steve French4523cc32007-04-30 20:13:06 +00001045 if (cifs_min_rcv < 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 cifs_min_rcv = 1;
1047 else if (cifs_min_rcv > 64) {
1048 cifs_min_rcv = 64;
Joe Perchesf96637b2013-05-04 22:12:25 -05001049 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 }
1051
Matthew Dobson93d23412006-03-26 01:37:50 -08001052 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1053 cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054
Steve French4523cc32007-04-30 20:13:06 +00001055 if (cifs_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 kmem_cache_destroy(cifs_req_cachep);
1057 return -ENOMEM;
1058 }
Steve Frenchec637e32005-12-12 20:53:18 -08001059 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 almost all handle based requests (but not write response, nor is it
1061 sufficient for path based requests). A smaller size would have
Steve French50c2f752007-07-13 00:33:32 +00001062 been more efficient (compacting multiple slab items on one 4k page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 for the case in which debug was on, but this larger size allows
1064 more SMBs to use small buffer alloc and is still much more
Steve French6dc0f872007-07-06 23:13:06 +00001065 efficient to alloc 1 per page off the slab compared to 17K (5page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 alloc of large cifs buffers even when page debugging is on */
1067 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
Steve French6dc0f872007-07-06 23:13:06 +00001068 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +09001069 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 if (cifs_sm_req_cachep == NULL) {
1071 mempool_destroy(cifs_req_poolp);
1072 kmem_cache_destroy(cifs_req_cachep);
Steve French6dc0f872007-07-06 23:13:06 +00001073 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 }
1075
Steve French4523cc32007-04-30 20:13:06 +00001076 if (cifs_min_small < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 cifs_min_small = 2;
1078 else if (cifs_min_small > 256) {
1079 cifs_min_small = 256;
Joe Perchesf96637b2013-05-04 22:12:25 -05001080 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 }
1082
Matthew Dobson93d23412006-03-26 01:37:50 -08001083 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1084 cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085
Steve French4523cc32007-04-30 20:13:06 +00001086 if (cifs_sm_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 mempool_destroy(cifs_req_poolp);
1088 kmem_cache_destroy(cifs_req_cachep);
1089 kmem_cache_destroy(cifs_sm_req_cachep);
1090 return -ENOMEM;
1091 }
1092
1093 return 0;
1094}
1095
1096static void
1097cifs_destroy_request_bufs(void)
1098{
1099 mempool_destroy(cifs_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001100 kmem_cache_destroy(cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 mempool_destroy(cifs_sm_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001102 kmem_cache_destroy(cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103}
1104
1105static int
1106cifs_init_mids(void)
1107{
1108 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
Steve French26f57362007-08-30 22:09:15 +00001109 sizeof(struct mid_q_entry), 0,
1110 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 if (cifs_mid_cachep == NULL)
1112 return -ENOMEM;
1113
Matthew Dobson93d23412006-03-26 01:37:50 -08001114 /* 3 is a reasonable minimum number of simultaneous operations */
1115 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
Steve French4523cc32007-04-30 20:13:06 +00001116 if (cifs_mid_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 kmem_cache_destroy(cifs_mid_cachep);
1118 return -ENOMEM;
1119 }
1120
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 return 0;
1122}
1123
1124static void
1125cifs_destroy_mids(void)
1126{
1127 mempool_destroy(cifs_mid_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001128 kmem_cache_destroy(cifs_mid_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129}
1130
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131static int __init
1132init_cifs(void)
1133{
1134 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135 cifs_proc_init();
Jeff Laytone7ddee92008-11-14 13:44:38 -05001136 INIT_LIST_HEAD(&cifs_tcp_ses_list);
Steve French0eff0e22011-02-24 05:39:23 +00001137#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
Steve French4ca9c192005-10-10 19:52:13 -07001138 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1139 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
Steve French0eff0e22011-02-24 05:39:23 +00001140#endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141/*
1142 * Initialize Global counters
1143 */
1144 atomic_set(&sesInfoAllocCount, 0);
1145 atomic_set(&tconInfoAllocCount, 0);
Steve French6dc0f872007-07-06 23:13:06 +00001146 atomic_set(&tcpSesAllocCount, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 atomic_set(&tcpSesReconnectCount, 0);
1148 atomic_set(&tconInfoReconnectCount, 0);
1149
1150 atomic_set(&bufAllocCount, 0);
Steve French4498eed52005-12-03 13:58:57 -08001151 atomic_set(&smBufAllocCount, 0);
1152#ifdef CONFIG_CIFS_STATS2
1153 atomic_set(&totBufAllocCount, 0);
1154 atomic_set(&totSmBufAllocCount, 0);
1155#endif /* CONFIG_CIFS_STATS2 */
1156
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 atomic_set(&midCount, 0);
1158 GlobalCurrentXid = 0;
1159 GlobalTotalActiveXid = 0;
1160 GlobalMaxActiveXid = 0;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301161 spin_lock_init(&cifs_tcp_ses_lock);
Jeff Layton44772882010-10-15 15:34:03 -04001162 spin_lock_init(&cifs_file_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 spin_lock_init(&GlobalMid_Lock);
1164
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -07001165#ifdef CONFIG_CIFS_SMB2
1166 get_random_bytes(cifs_client_guid, SMB2_CLIENT_GUID_SIZE);
1167#endif
1168
Steve French4523cc32007-04-30 20:13:06 +00001169 if (cifs_max_pending < 2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 cifs_max_pending = 2;
Joe Perchesf96637b2013-05-04 22:12:25 -05001171 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
Pavel Shilovsky10b9b982012-03-20 12:55:09 +03001172 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1173 cifs_max_pending = CIFS_MAX_REQ;
Joe Perchesf96637b2013-05-04 22:12:25 -05001174 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1175 CIFS_MAX_REQ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 }
1177
Jeff Laytonda472fc2012-03-23 14:40:53 -04001178 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1179 if (!cifsiod_wq) {
1180 rc = -ENOMEM;
1181 goto out_clean_proc;
1182 }
1183
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301184 rc = cifs_fscache_register();
1185 if (rc)
Jeff Laytonda472fc2012-03-23 14:40:53 -04001186 goto out_destroy_wq;
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301187
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 rc = cifs_init_inodecache();
Steve French45af7a02006-04-21 22:52:25 +00001189 if (rc)
Steve Frenchd3bf5222010-09-22 19:15:36 +00001190 goto out_unreg_fscache;
Steve French45af7a02006-04-21 22:52:25 +00001191
1192 rc = cifs_init_mids();
1193 if (rc)
1194 goto out_destroy_inodecache;
1195
1196 rc = cifs_init_request_bufs();
1197 if (rc)
1198 goto out_destroy_mids;
1199
Jeff Layton84a15b92007-11-03 05:02:24 +00001200#ifdef CONFIG_CIFS_UPCALL
1201 rc = register_key_type(&cifs_spnego_key_type);
1202 if (rc)
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001203 goto out_destroy_request_bufs;
1204#endif /* CONFIG_CIFS_UPCALL */
1205
1206#ifdef CONFIG_CIFS_ACL
1207 rc = init_cifs_idmap();
1208 if (rc)
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001209 goto out_register_key_type;
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001210#endif /* CONFIG_CIFS_ACL */
1211
1212 rc = register_filesystem(&cifs_fs_type);
1213 if (rc)
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001214 goto out_init_cifs_idmap;
Steve French45af7a02006-04-21 22:52:25 +00001215
Steve French45af7a02006-04-21 22:52:25 +00001216 return 0;
1217
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001218out_init_cifs_idmap:
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001219#ifdef CONFIG_CIFS_ACL
1220 exit_cifs_idmap();
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001221out_register_key_type:
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001222#endif
1223#ifdef CONFIG_CIFS_UPCALL
1224 unregister_key_type(&cifs_spnego_key_type);
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001225out_destroy_request_bufs:
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001226#endif
Steve French45af7a02006-04-21 22:52:25 +00001227 cifs_destroy_request_bufs();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001228out_destroy_mids:
Steve French45af7a02006-04-21 22:52:25 +00001229 cifs_destroy_mids();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001230out_destroy_inodecache:
Steve French45af7a02006-04-21 22:52:25 +00001231 cifs_destroy_inodecache();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001232out_unreg_fscache:
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301233 cifs_fscache_unregister();
Jeff Laytonda472fc2012-03-23 14:40:53 -04001234out_destroy_wq:
1235 destroy_workqueue(cifsiod_wq);
Steve Frenchd3bf5222010-09-22 19:15:36 +00001236out_clean_proc:
1237 cifs_proc_clean();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 return rc;
1239}
1240
1241static void __exit
1242exit_cifs(void)
1243{
Joe Perchesf96637b2013-05-04 22:12:25 -05001244 cifs_dbg(NOISY, "exit_cifs\n");
Jeff Layton3dd93302012-03-21 06:27:55 -04001245 unregister_filesystem(&cifs_fs_type);
Igor Mammedov78d31a32008-04-24 12:56:07 +04001246 cifs_dfs_release_automount_timer();
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001247#ifdef CONFIG_CIFS_ACL
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001248 exit_cifs_idmap();
1249#endif
Jeff Layton84a15b92007-11-03 05:02:24 +00001250#ifdef CONFIG_CIFS_UPCALL
1251 unregister_key_type(&cifs_spnego_key_type);
1252#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 cifs_destroy_request_bufs();
Jeff Layton3dd93302012-03-21 06:27:55 -04001254 cifs_destroy_mids();
1255 cifs_destroy_inodecache();
1256 cifs_fscache_unregister();
Jeff Laytonda472fc2012-03-23 14:40:53 -04001257 destroy_workqueue(cifsiod_wq);
Jeff Layton3dd93302012-03-21 06:27:55 -04001258 cifs_proc_clean();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259}
1260
1261MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
Steve French6dc0f872007-07-06 23:13:06 +00001262MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263MODULE_DESCRIPTION
Steve French63135e02007-07-17 17:34:02 +00001264 ("VFS to access servers complying with the SNIA CIFS Specification "
1265 "e.g. Samba and Windows");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266MODULE_VERSION(CIFS_VERSION);
1267module_init(init_cifs)
1268module_exit(exit_cifs)