blob: 8f1fe324162b4203fc245c9032052f6862623501 [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>
Ben Greear3eb9a882010-09-01 17:06:02 -070039#include <net/ipv6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include "cifsfs.h"
41#include "cifspdu.h"
42#define DECLARE_GLOBALS_HERE
43#include "cifsglob.h"
44#include "cifsproto.h"
45#include "cifs_debug.h"
46#include "cifs_fs_sb.h"
47#include <linux/mm.h>
Jeff Layton84a15b92007-11-03 05:02:24 +000048#include <linux/key-type.h>
Jeff Laytone5459372007-11-03 05:11:06 +000049#include "cifs_spnego.h"
Suresh Jayaramanf579cf32010-07-05 18:11:50 +053050#include "fscache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
52
Linus Torvalds1da177e2005-04-16 15:20:36 -070053int cifsFYI = 0;
54int cifsERROR = 1;
55int traceSMB = 0;
Steve Frenche7504732011-10-12 17:47:03 -050056bool enable_oplocks = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057unsigned int linuxExtEnabled = 1;
58unsigned int lookupCacheEnabled = 1;
59unsigned int multiuser_mount = 0;
Jeff Layton04912d62010-04-24 07:57:45 -040060unsigned int global_secflags = CIFSSEC_DEF;
Steve French39798772006-05-31 22:40:51 +000061/* unsigned int ntlmv2_support = 0; */
Linus Torvalds1da177e2005-04-16 15:20:36 -070062unsigned int sign_CIFS_PDUs = 1;
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -080063static const struct super_operations cifs_super_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070064unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
65module_param(CIFSMaxBufSize, int, 0);
Steve French63135e02007-07-17 17:34:02 +000066MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
67 "Default: 16384 Range: 8192 to 130048");
Linus Torvalds1da177e2005-04-16 15:20:36 -070068unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
69module_param(cifs_min_rcv, int, 0);
Steve French63135e02007-07-17 17:34:02 +000070MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
71 "1 to 64");
Linus Torvalds1da177e2005-04-16 15:20:36 -070072unsigned int cifs_min_small = 30;
73module_param(cifs_min_small, int, 0);
Steve French63135e02007-07-17 17:34:02 +000074MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
75 "Range: 2 to 256");
Linus Torvalds1da177e2005-04-16 15:20:36 -070076unsigned int cifs_max_pending = CIFS_MAX_REQ;
Jeff Laytonfef33df2011-10-19 15:30:37 -040077module_param(cifs_max_pending, int, 0444);
Steve French63135e02007-07-17 17:34:02 +000078MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
79 "Default: 50 Range: 2 to 256");
Steve Frenchfda35942011-01-20 18:06:34 +000080unsigned short echo_retries = 5;
81module_param(echo_retries, ushort, 0644);
82MODULE_PARM_DESC(echo_retries, "Number of echo attempts before giving up and "
83 "reconnecting server. Default: 5. 0 means "
84 "never reconnect.");
Steve Frenche7504732011-10-12 17:47:03 -050085module_param(enable_oplocks, bool, 0644);
86MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks (bool). Default:"
87 "y/Y/1");
88
Linus Torvalds1da177e2005-04-16 15:20:36 -070089extern mempool_t *cifs_sm_req_poolp;
90extern mempool_t *cifs_req_poolp;
91extern mempool_t *cifs_mid_poolp;
92
Linus Torvalds1da177e2005-04-16 15:20:36 -070093static int
Al Viro97d11522011-06-17 09:29:57 -040094cifs_read_super(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070095{
96 struct inode *inode;
Pavel Shilovskyb2e5cd32011-05-25 13:35:34 +040097 struct cifs_sb_info *cifs_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +000099
Pavel Shilovskyb2e5cd32011-05-25 13:35:34 +0400100 cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
Al Viro2c6292a2011-06-17 09:05:48 -0400102 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
103 sb->s_flags |= MS_POSIXACL;
104
105 if (cifs_sb_master_tcon(cifs_sb)->ses->capabilities & CAP_LARGE_FILES)
106 sb->s_maxbytes = MAX_LFS_FILESIZE;
107 else
108 sb->s_maxbytes = MAX_NON_LFS;
109
110 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
111 sb->s_time_gran = 100;
112
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 sb->s_magic = CIFS_MAGIC_NUMBER;
114 sb->s_op = &cifs_super_ops;
Jens Axboe8044f7f2010-04-22 12:09:48 +0200115 sb->s_bdi = &cifs_sb->bdi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 sb->s_blocksize = CIFS_MAX_MSGSIZE;
117 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
Shirish Pargaonkar9b6763e2011-02-21 23:56:59 -0600118 inode = cifs_root_iget(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
David Howellsce634ab2008-02-07 00:15:33 -0800120 if (IS_ERR(inode)) {
121 rc = PTR_ERR(inode);
122 inode = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 goto out_no_root;
124 }
125
126 sb->s_root = d_alloc_root(inode);
127
128 if (!sb->s_root) {
129 rc = -ENOMEM;
130 goto out_no_root;
131 }
Steve French50c2f752007-07-13 00:33:32 +0000132
Al Viro1c929cf2010-12-18 11:43:51 -0500133 /* do that *after* d_alloc_root() - we want NULL ->d_op for root here */
134 if (cifs_sb_master_tcon(cifs_sb)->nocase)
135 sb->s_d_op = &cifs_ci_dentry_ops;
136 else
137 sb->s_d_op = &cifs_dentry_ops;
138
Paul Bollef3a6a602011-10-12 14:14:04 +0200139#ifdef CONFIG_CIFS_NFSD_EXPORT
Steve French7521a3c2007-07-11 18:30:34 +0000140 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000141 cFYI(1, "export ops supported");
Steve French7521a3c2007-07-11 18:30:34 +0000142 sb->s_export_op = &cifs_export_ops;
143 }
Paul Bollef3a6a602011-10-12 14:14:04 +0200144#endif /* CONFIG_CIFS_NFSD_EXPORT */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145
146 return 0;
147
148out_no_root:
Joe Perchesb6b38f72010-04-21 03:50:45 +0000149 cERROR(1, "cifs_read_super: get root inode failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 if (inode)
151 iput(inode);
Steve French54b46022008-08-11 22:31:40 +0000152
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 return rc;
154}
155
Al Viro6d686172011-06-17 08:34:57 -0400156static void cifs_kill_sb(struct super_block *sb)
157{
158 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
159 kill_anon_super(sb);
Al Viro98ab4942011-06-17 09:32:10 -0400160 cifs_umount(cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161}
162
163static int
David Howells726c3342006-06-23 02:02:58 -0700164cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165{
David Howells726c3342006-06-23 02:02:58 -0700166 struct super_block *sb = dentry->d_sb;
Steve French39da9842008-04-28 04:04:34 +0000167 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French96daf2b2011-05-27 04:34:02 +0000168 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Steve Frenchc81156d2005-04-28 22:41:07 -0700169 int rc = -EOPNOTSUPP;
Steve French39da9842008-04-28 04:04:34 +0000170 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171
172 xid = GetXid();
173
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 buf->f_type = CIFS_MAGIC_NUMBER;
175
Steve French39da9842008-04-28 04:04:34 +0000176 /*
177 * PATH_MAX may be too long - it would presumably be total path,
178 * but note that some servers (includinng Samba 3) have a shorter
179 * maximum path.
180 *
181 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
182 */
183 buf->f_namelen = PATH_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 buf->f_files = 0; /* undefined */
185 buf->f_ffree = 0; /* unlimited */
186
Steve French39da9842008-04-28 04:04:34 +0000187 /*
188 * We could add a second check for a QFS Unix capability bit
189 */
190 if ((tcon->ses->capabilities & CAP_UNIX) &&
191 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
192 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
Steve French39da9842008-04-28 04:04:34 +0000194 /*
195 * Only need to call the old QFSInfo if failed on newer one,
196 * e.g. by OS/2.
197 **/
198 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
199 rc = CIFSSMBQFSInfo(xid, tcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200
Steve French39da9842008-04-28 04:04:34 +0000201 /*
202 * Some old Windows servers also do not support level 103, retry with
203 * older level one if old server failed the previous call or we
204 * bypassed it because we detected that this was an older LANMAN sess
205 */
Steve French4523cc32007-04-30 20:13:06 +0000206 if (rc)
Steve French39da9842008-04-28 04:04:34 +0000207 rc = SMBOldQFSInfo(xid, tcon, buf);
208
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 FreeXid(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;
248 /* Until the file is open and we have gotten oplock
249 info back from the server, can not assume caching of
250 file data or metadata */
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300251 cifs_set_oplock_level(cifs_inode, 0);
Jeff Layton9a8165f2008-10-17 21:03:20 -0400252 cifs_inode->delete_pending = false;
Jeff Laytondf2cf172010-02-12 07:44:16 -0500253 cifs_inode->invalid_mapping = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400255 cifs_inode->server_eof = 0;
Jeff Layton20054bd2011-01-07 11:30:27 -0500256 cifs_inode->uniqueid = 0;
257 cifs_inode->createtime = 0;
Steve French50c2f752007-07-13 00:33:32 +0000258
Steve French1b2b2122007-02-17 04:30:54 +0000259 /* Can not set i_flags here - they get immediately overwritten
260 to zero by the VFS */
261/* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 INIT_LIST_HEAD(&cifs_inode->openFileList);
263 return &cifs_inode->vfs_inode;
264}
265
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100266static void cifs_i_callback(struct rcu_head *head)
267{
268 struct inode *inode = container_of(head, struct inode, i_rcu);
269 INIT_LIST_HEAD(&inode->i_dentry);
270 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
271}
272
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273static void
274cifs_destroy_inode(struct inode *inode)
275{
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100276 call_rcu(&inode->i_rcu, cifs_i_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277}
278
Jeff Layton61f98ff2009-06-11 10:27:32 -0400279static void
Al Virob57922d2010-06-07 14:34:48 -0400280cifs_evict_inode(struct inode *inode)
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530281{
Al Virob57922d2010-06-07 14:34:48 -0400282 truncate_inode_pages(&inode->i_data, 0);
283 end_writeback(inode);
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530284 cifs_fscache_release_inode_cookie(inode);
285}
286
287static void
Jeff Layton61f98ff2009-06-11 10:27:32 -0400288cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
289{
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300290 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
291 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
292
Jeff Layton61f98ff2009-06-11 10:27:32 -0400293 seq_printf(s, ",addr=");
294
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300295 switch (server->dstaddr.ss_family) {
Jeff Layton61f98ff2009-06-11 10:27:32 -0400296 case AF_INET:
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300297 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
Jeff Layton61f98ff2009-06-11 10:27:32 -0400298 break;
299 case AF_INET6:
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300300 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
301 if (sa6->sin6_scope_id)
302 seq_printf(s, "%%%u", sa6->sin6_scope_id);
Jeff Layton61f98ff2009-06-11 10:27:32 -0400303 break;
304 default:
305 seq_printf(s, "(unknown)");
306 }
307}
308
Jeff Layton3e715512011-06-13 11:50:41 -0400309static void
310cifs_show_security(struct seq_file *s, struct TCP_Server_Info *server)
311{
312 seq_printf(s, ",sec=");
313
314 switch (server->secType) {
315 case LANMAN:
316 seq_printf(s, "lanman");
317 break;
318 case NTLMv2:
319 seq_printf(s, "ntlmv2");
320 break;
321 case NTLM:
322 seq_printf(s, "ntlm");
323 break;
324 case Kerberos:
325 seq_printf(s, "krb5");
326 break;
327 case RawNTLMSSP:
328 seq_printf(s, "ntlmssp");
329 break;
330 default:
331 /* shouldn't ever happen */
332 seq_printf(s, "unknown");
333 break;
334 }
335
336 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
337 seq_printf(s, "i");
338}
339
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340/*
341 * cifs_show_options() is for displaying mount options in /proc/mounts.
342 * Not all settable options are displayed but most of the important
343 * ones are.
344 */
345static int
346cifs_show_options(struct seq_file *s, struct vfsmount *m)
347{
Jeff Layton8e047d02009-08-28 10:11:10 -0400348 struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
Steve French96daf2b2011-05-27 04:34:02 +0000349 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Ben Greear3eb9a882010-09-01 17:06:02 -0700350 struct sockaddr *srcaddr;
351 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352
Jeff Layton3e715512011-06-13 11:50:41 -0400353 cifs_show_security(s, tcon->ses->server);
354
Jeff Layton8e047d02009-08-28 10:11:10 -0400355 seq_printf(s, ",unc=%s", tcon->treeName);
Jeff Layton29e07c82010-09-29 19:51:12 -0400356
357 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
358 seq_printf(s, ",multiuser");
Steve French8727c8a2011-02-25 01:11:56 -0600359 else if (tcon->ses->user_name)
360 seq_printf(s, ",username=%s", tcon->ses->user_name);
Jeff Layton29e07c82010-09-29 19:51:12 -0400361
Jeff Layton8616e0f2009-06-11 10:27:28 -0400362 if (tcon->ses->domainName)
363 seq_printf(s, ",domain=%s", tcon->ses->domainName);
364
Ben Greear3eb9a882010-09-01 17:06:02 -0700365 if (srcaddr->sa_family != AF_UNSPEC) {
366 struct sockaddr_in *saddr4;
367 struct sockaddr_in6 *saddr6;
368 saddr4 = (struct sockaddr_in *)srcaddr;
369 saddr6 = (struct sockaddr_in6 *)srcaddr;
370 if (srcaddr->sa_family == AF_INET6)
371 seq_printf(s, ",srcaddr=%pI6c",
372 &saddr6->sin6_addr);
373 else if (srcaddr->sa_family == AF_INET)
374 seq_printf(s, ",srcaddr=%pI4",
375 &saddr4->sin_addr.s_addr);
376 else
377 seq_printf(s, ",srcaddr=BAD-AF:%i",
378 (int)(srcaddr->sa_family));
379 }
380
Jeff Layton8616e0f2009-06-11 10:27:28 -0400381 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
Jeff Layton340481a32009-06-11 10:27:29 -0400382 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
383 seq_printf(s, ",forceuid");
Jeff Layton4486d6e2009-08-03 12:45:10 -0400384 else
385 seq_printf(s, ",noforceuid");
Jeff Layton340481a32009-06-11 10:27:29 -0400386
Jeff Layton8616e0f2009-06-11 10:27:28 -0400387 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
Jeff Layton340481a32009-06-11 10:27:29 -0400388 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
389 seq_printf(s, ",forcegid");
Jeff Layton4486d6e2009-08-03 12:45:10 -0400390 else
391 seq_printf(s, ",noforcegid");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400392
Jeff Layton61f98ff2009-06-11 10:27:32 -0400393 cifs_show_address(s, tcon->ses->server);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400394
395 if (!tcon->unix_ext)
396 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
Steve French2b280fa2008-05-17 03:12:45 +0000397 cifs_sb->mnt_file_mode,
398 cifs_sb->mnt_dir_mode);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400399 if (tcon->seal)
400 seq_printf(s, ",seal");
401 if (tcon->nocase)
402 seq_printf(s, ",nocase");
403 if (tcon->retry)
404 seq_printf(s, ",hard");
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000405 if (tcon->unix_ext)
406 seq_printf(s, ",unix");
407 else
408 seq_printf(s, ",nounix");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400409 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
410 seq_printf(s, ",posixpaths");
411 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
412 seq_printf(s, ",setuids");
413 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
414 seq_printf(s, ",serverino");
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000415 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
416 seq_printf(s, ",rwpidforward");
417 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
418 seq_printf(s, ",forcemand");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400419 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
420 seq_printf(s, ",directio");
421 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
422 seq_printf(s, ",nouser_xattr");
423 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
424 seq_printf(s, ",mapchars");
425 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
426 seq_printf(s, ",sfu");
427 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
428 seq_printf(s, ",nobrl");
429 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
430 seq_printf(s, ",cifsacl");
431 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
432 seq_printf(s, ",dynperm");
433 if (m->mnt_sb->s_flags & MS_POSIXACL)
434 seq_printf(s, ",acl");
Stefan Metzmacher736a3322010-07-30 14:56:00 +0200435 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
436 seq_printf(s, ",mfsymlinks");
Suresh Jayaraman476428f2010-11-24 17:49:07 +0530437 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
438 seq_printf(s, ",fsc");
Steve French71c424b2011-10-19 20:44:48 -0500439 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
440 seq_printf(s, ",nostrictsync");
441 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
442 seq_printf(s, ",noperm");
Sachin Prabhu875cd042011-10-11 13:43:50 +0100443 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
444 seq_printf(s, ",strictcache");
Steve French2b280fa2008-05-17 03:12:45 +0000445
Jeff Layton8616e0f2009-06-11 10:27:28 -0400446 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
447 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
Suresh Jayaraman6d20e842010-12-01 14:42:28 +0530448 /* convert actimeo and display it in seconds */
449 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400450
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 return 0;
452}
453
Al Viro42faad92008-04-24 07:21:56 -0400454static void cifs_umount_begin(struct super_block *sb)
Steve French68058e72005-10-10 10:34:22 -0700455{
Al Viro42faad92008-04-24 07:21:56 -0400456 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French96daf2b2011-05-27 04:34:02 +0000457 struct cifs_tcon *tcon;
Steve French68058e72005-10-10 10:34:22 -0700458
Steve French4523cc32007-04-30 20:13:06 +0000459 if (cifs_sb == NULL)
Steve French9e2e85f2005-10-10 14:28:38 -0700460 return;
461
Jeff Layton0d424ad2010-09-20 16:01:35 -0700462 tcon = cifs_sb_master_tcon(cifs_sb);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500463
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530464 spin_lock(&cifs_tcp_ses_lock);
Steve Frenchad8034f2009-06-26 03:25:49 +0000465 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
466 /* we have other mounts to same share or we have
467 already tried to force umount this and woken up
468 all waiting network requests, nothing to do */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530469 spin_unlock(&cifs_tcp_ses_lock);
Steve Frenchad8034f2009-06-26 03:25:49 +0000470 return;
471 } else if (tcon->tc_count == 1)
Steve French5e1253b2005-10-10 14:06:37 -0700472 tcon->tidStatus = CifsExiting;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530473 spin_unlock(&cifs_tcp_ses_lock);
Steve French5e1253b2005-10-10 14:06:37 -0700474
Steve French3a5ff612006-07-14 22:37:11 +0000475 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
Steve French7b7abfe2005-11-09 15:21:09 -0800476 /* cancel_notify_requests(tcon); */
Steve French50c2f752007-07-13 00:33:32 +0000477 if (tcon->ses && tcon->ses->server) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000478 cFYI(1, "wake up tasks now - umount begin not complete");
Steve French9e2e85f2005-10-10 14:28:38 -0700479 wake_up_all(&tcon->ses->server->request_q);
Steve French6ab16d22005-11-29 20:55:11 -0800480 wake_up_all(&tcon->ses->server->response_q);
481 msleep(1); /* yield */
482 /* we have to kick the requests once more */
483 wake_up_all(&tcon->ses->server->response_q);
484 msleep(1);
Steve French5e1253b2005-10-10 14:06:37 -0700485 }
Steve French68058e72005-10-10 10:34:22 -0700486
487 return;
488}
Steve French68058e72005-10-10 10:34:22 -0700489
Steve Frenchbf97d282006-09-28 21:34:06 +0000490#ifdef CONFIG_CIFS_STATS2
491static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
492{
493 /* BB FIXME */
494 return 0;
495}
496#endif
497
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498static int cifs_remount(struct super_block *sb, int *flags, char *data)
499{
500 *flags |= MS_NODIRATIME;
501 return 0;
502}
503
Al Viro45321ac2010-06-07 13:43:19 -0400504static int cifs_drop_inode(struct inode *inode)
Jeff Layton12420ac2010-06-01 14:47:40 -0400505{
506 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
507
Al Viro45321ac2010-06-07 13:43:19 -0400508 /* no serverino => unconditional eviction */
509 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
510 generic_drop_inode(inode);
Jeff Layton12420ac2010-06-01 14:47:40 -0400511}
512
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800513static const struct super_operations cifs_super_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 .statfs = cifs_statfs,
515 .alloc_inode = cifs_alloc_inode,
516 .destroy_inode = cifs_destroy_inode,
Jeff Layton12420ac2010-06-01 14:47:40 -0400517 .drop_inode = cifs_drop_inode,
Al Virob57922d2010-06-07 14:34:48 -0400518 .evict_inode = cifs_evict_inode,
Jeff Layton12420ac2010-06-01 14:47:40 -0400519/* .delete_inode = cifs_delete_inode, */ /* Do not need above
520 function unless later we add lazy close of inodes or unless the
Steve French50c2f752007-07-13 00:33:32 +0000521 kernel forgets to call us with the same number of releases (closes)
522 as opens */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 .show_options = cifs_show_options,
Steve French7b7abfe2005-11-09 15:21:09 -0800524 .umount_begin = cifs_umount_begin,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 .remount_fs = cifs_remount,
Steve Frenchbf97d282006-09-28 21:34:06 +0000526#ifdef CONFIG_CIFS_STATS2
Steve Frenchf46d3e12006-09-30 01:08:55 +0000527 .show_stats = cifs_show_stats,
Steve Frenchbf97d282006-09-28 21:34:06 +0000528#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529};
530
Steve Frenchf87d39d2011-05-27 03:50:55 +0000531/*
532 * Get root dentry from superblock according to prefix path mount option.
533 * Return dentry with refcount + 1 on success and NULL otherwise.
534 */
535static struct dentry *
536cifs_get_root(struct smb_vol *vol, struct super_block *sb)
537{
Al Virofec11dd2011-07-18 13:50:40 -0400538 struct dentry *dentry;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000539 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Al Virofec11dd2011-07-18 13:50:40 -0400540 char *full_path = NULL;
541 char *s, *p;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000542 char sep;
543
544 full_path = cifs_build_path_to_root(vol, cifs_sb,
545 cifs_sb_master_tcon(cifs_sb));
546 if (full_path == NULL)
Al Viro9403c9c2011-06-17 10:02:59 -0400547 return ERR_PTR(-ENOMEM);
Steve Frenchf87d39d2011-05-27 03:50:55 +0000548
549 cFYI(1, "Get root dentry for %s", full_path);
550
Steve Frenchf87d39d2011-05-27 03:50:55 +0000551 sep = CIFS_DIR_SEP(cifs_sb);
Al Virofec11dd2011-07-18 13:50:40 -0400552 dentry = dget(sb->s_root);
553 p = s = full_path;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000554
Al Virofec11dd2011-07-18 13:50:40 -0400555 do {
556 struct inode *dir = dentry->d_inode;
557 struct dentry *child;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000558
Pavel Shilovsky5b980b02011-08-21 19:30:15 +0400559 if (!dir) {
560 dput(dentry);
561 dentry = ERR_PTR(-ENOENT);
562 break;
563 }
564
Al Virofec11dd2011-07-18 13:50:40 -0400565 /* skip separators */
566 while (*s == sep)
567 s++;
568 if (!*s)
569 break;
570 p = s++;
571 /* next separator */
572 while (*s && *s != sep)
573 s++;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000574
Al Virofec11dd2011-07-18 13:50:40 -0400575 mutex_lock(&dir->i_mutex);
576 child = lookup_one_len(p, dentry, s - p);
577 mutex_unlock(&dir->i_mutex);
578 dput(dentry);
579 dentry = child;
580 } while (!IS_ERR(dentry));
Steve Frenchf87d39d2011-05-27 03:50:55 +0000581 kfree(full_path);
Al Virofec11dd2011-07-18 13:50:40 -0400582 return dentry;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000583}
584
Al Viroee01a142011-06-17 09:47:23 -0400585static int cifs_set_super(struct super_block *sb, void *data)
586{
587 struct cifs_mnt_data *mnt_data = data;
588 sb->s_fs_info = mnt_data->cifs_sb;
589 return set_anon_super(sb, NULL);
590}
591
Al Virod753ed92010-07-26 12:52:33 +0400592static struct dentry *
593cifs_do_mount(struct file_system_type *fs_type,
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000594 int flags, const char *dev_name, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595{
596 int rc;
Jan Blunckdb719222010-08-15 22:51:10 +0200597 struct super_block *sb;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000598 struct cifs_sb_info *cifs_sb;
599 struct smb_vol *volume_info;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400600 struct cifs_mnt_data mnt_data;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000601 struct dentry *root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
Joe Perchesb6b38f72010-04-21 03:50:45 +0000603 cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
Jeff Layton04db79b2011-07-06 08:10:38 -0400605 volume_info = cifs_get_volume_info((char *)data, dev_name);
606 if (IS_ERR(volume_info))
607 return ERR_CAST(volume_info);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000608
609 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
610 if (cifs_sb == NULL) {
611 root = ERR_PTR(-ENOMEM);
Al Viro5c4f1ad2011-06-17 09:56:55 -0400612 goto out_nls;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000613 }
614
Al Viro5d3bc602011-06-17 09:17:28 -0400615 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
616 if (cifs_sb->mountdata == NULL) {
617 root = ERR_PTR(-ENOMEM);
Al Viro5c4f1ad2011-06-17 09:56:55 -0400618 goto out_cifs_sb;
Al Viro5d3bc602011-06-17 09:17:28 -0400619 }
620
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000621 cifs_setup_cifs_sb(volume_info, cifs_sb);
622
Al Viro97d11522011-06-17 09:29:57 -0400623 rc = cifs_mount(cifs_sb, volume_info);
624 if (rc) {
625 if (!(flags & MS_SILENT))
626 cERROR(1, "cifs_mount failed w/return code = %d", rc);
627 root = ERR_PTR(rc);
Al Viro5c4f1ad2011-06-17 09:56:55 -0400628 goto out_mountdata;
Al Viro97d11522011-06-17 09:29:57 -0400629 }
630
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400631 mnt_data.vol = volume_info;
632 mnt_data.cifs_sb = cifs_sb;
633 mnt_data.flags = flags;
634
Al Viroee01a142011-06-17 09:47:23 -0400635 sb = sget(fs_type, cifs_match_super, cifs_set_super, &mnt_data);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000636 if (IS_ERR(sb)) {
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000637 root = ERR_CAST(sb);
Al Viro97d11522011-06-17 09:29:57 -0400638 cifs_umount(cifs_sb);
Al Virod757d712011-06-17 09:42:43 -0400639 goto out;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000640 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641
Al Viroee01a142011-06-17 09:47:23 -0400642 if (sb->s_root) {
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400643 cFYI(1, "Use existing superblock");
Al Viro97d11522011-06-17 09:29:57 -0400644 cifs_umount(cifs_sb);
Al Viro5c4f1ad2011-06-17 09:56:55 -0400645 } else {
646 sb->s_flags = flags;
647 /* BB should we make this contingent on mount parm? */
648 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
649
650 rc = cifs_read_super(sb);
651 if (rc) {
652 root = ERR_PTR(rc);
653 goto out_super;
654 }
655
656 sb->s_flags |= MS_ACTIVE;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400657 }
658
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400659 root = cifs_get_root(volume_info, sb);
Al Viro9403c9c2011-06-17 10:02:59 -0400660 if (IS_ERR(root))
Al Virofa18f1b2011-06-17 09:50:44 -0400661 goto out_super;
Al Virofa18f1b2011-06-17 09:50:44 -0400662
663 cFYI(1, "dentry root is: %p", root);
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400664 goto out;
665
Pavel Shilovsky641a58d2011-05-26 00:02:16 +0400666out_super:
Pavel Shilovsky641a58d2011-05-26 00:02:16 +0400667 deactivate_locked_super(sb);
Pavel Shilovsky641a58d2011-05-26 00:02:16 +0400668out:
Jeff Laytonf9e59bc2011-07-06 08:10:37 -0400669 cifs_cleanup_volume_info(volume_info);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000670 return root;
Al Viro5c4f1ad2011-06-17 09:56:55 -0400671
672out_mountdata:
673 kfree(cifs_sb->mountdata);
674out_cifs_sb:
675 kfree(cifs_sb);
676out_nls:
677 unload_nls(volume_info->local_nls);
678 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679}
680
Badari Pulavarty027445c2006-09-30 23:28:46 -0700681static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
682 unsigned long nr_segs, loff_t pos)
Steve French87c89dd2005-11-17 17:03:00 -0800683{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800684 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
Steve French87c89dd2005-11-17 17:03:00 -0800685 ssize_t written;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500686 int rc;
Steve French87c89dd2005-11-17 17:03:00 -0800687
Badari Pulavarty027445c2006-09-30 23:28:46 -0700688 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500689
690 if (CIFS_I(inode)->clientCanCacheAll)
691 return written;
692
693 rc = filemap_fdatawrite(inode->i_mapping);
694 if (rc)
695 cFYI(1, "cifs_file_aio_write: %d rc on %p inode", rc, inode);
696
Steve French87c89dd2005-11-17 17:03:00 -0800697 return written;
698}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699
Steve Frenchc32a0b62006-01-12 14:41:28 -0800700static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
701{
Josef Bacik06222e42011-07-18 13:21:38 -0400702 /*
703 * origin == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
704 * the cached file length
705 */
706 if (origin != SEEK_SET || origin != SEEK_CUR) {
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400707 int rc;
708 struct inode *inode = file->f_path.dentry->d_inode;
Steve French030e9d82007-02-01 04:27:59 +0000709
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400710 /*
711 * We need to be sure that all dirty pages are written and the
712 * server has the newest file length.
713 */
714 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
715 inode->i_mapping->nrpages != 0) {
716 rc = filemap_fdatawait(inode->i_mapping);
Steve French156ecb22011-05-20 17:00:01 +0000717 if (rc) {
718 mapping_set_error(inode->i_mapping, rc);
719 return rc;
720 }
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400721 }
722 /*
723 * Some applications poll for the file length in this strange
724 * way so we must seek to end on non-oplocked files by
725 * setting the revalidate time to zero.
726 */
727 CIFS_I(inode)->time = 0;
Steve French030e9d82007-02-01 04:27:59 +0000728
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400729 rc = cifs_revalidate_file_attr(file);
730 if (rc < 0)
731 return (loff_t)rc;
Steve Frenchc32a0b62006-01-12 14:41:28 -0800732 }
Andi Kleenef3d0fd2011-09-15 16:06:48 -0700733 return generic_file_llseek(file, offset, origin);
Steve Frenchc32a0b62006-01-12 14:41:28 -0800734}
735
Steve French84210e92008-10-23 04:42:37 +0000736static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
737{
Arnd Bergmannb89f4322010-09-18 15:09:31 +0200738 /* note that this is called by vfs setlease with lock_flocks held
739 to protect *lease from going away */
Steve French84210e92008-10-23 04:42:37 +0000740 struct inode *inode = file->f_path.dentry->d_inode;
Jeff Laytonba00ba62010-09-20 16:01:31 -0700741 struct cifsFileInfo *cfile = file->private_data;
Steve French84210e92008-10-23 04:42:37 +0000742
743 if (!(S_ISREG(inode->i_mode)))
744 return -EINVAL;
745
746 /* check if file is oplocked */
747 if (((arg == F_RDLCK) &&
748 (CIFS_I(inode)->clientCanCacheRead)) ||
749 ((arg == F_WRLCK) &&
750 (CIFS_I(inode)->clientCanCacheAll)))
751 return generic_setlease(file, arg, lease);
Jeff Layton13cfb732010-09-29 19:51:11 -0400752 else if (tlink_tcon(cfile->tlink)->local_lease &&
753 !CIFS_I(inode)->clientCanCacheRead)
Steve French84210e92008-10-23 04:42:37 +0000754 /* If the server claims to support oplock on this
755 file, then we still need to check oplock even
756 if the local_lease mount option is set, but there
757 are servers which do not support oplock for which
758 this mount option may be useful if the user
759 knows that the file won't be changed on the server
760 by anyone else */
761 return generic_setlease(file, arg, lease);
Christoph Hellwig51ee4b82010-10-31 08:35:10 -0400762 else
Steve French84210e92008-10-23 04:42:37 +0000763 return -EAGAIN;
764}
Steve French84210e92008-10-23 04:42:37 +0000765
Igor Mammedove6ab1582008-01-11 01:49:48 +0000766struct file_system_type cifs_fs_type = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 .owner = THIS_MODULE,
768 .name = "cifs",
Al Virod753ed92010-07-26 12:52:33 +0400769 .mount = cifs_do_mount,
Al Viro6d686172011-06-17 08:34:57 -0400770 .kill_sb = cifs_kill_sb,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 /* .fs_flags */
772};
Arjan van de Ven754661f2007-02-12 00:55:38 -0800773const struct inode_operations cifs_dir_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 .create = cifs_create,
775 .lookup = cifs_lookup,
776 .getattr = cifs_getattr,
777 .unlink = cifs_unlink,
778 .link = cifs_hardlink,
779 .mkdir = cifs_mkdir,
780 .rmdir = cifs_rmdir,
781 .rename = cifs_rename,
782 .permission = cifs_permission,
783/* revalidate:cifs_revalidate, */
784 .setattr = cifs_setattr,
785 .symlink = cifs_symlink,
786 .mknod = cifs_mknod,
787#ifdef CONFIG_CIFS_XATTR
788 .setxattr = cifs_setxattr,
789 .getxattr = cifs_getxattr,
790 .listxattr = cifs_listxattr,
791 .removexattr = cifs_removexattr,
792#endif
793};
794
Arjan van de Ven754661f2007-02-12 00:55:38 -0800795const struct inode_operations cifs_file_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796/* revalidate:cifs_revalidate, */
797 .setattr = cifs_setattr,
798 .getattr = cifs_getattr, /* do we need this anymore? */
799 .rename = cifs_rename,
800 .permission = cifs_permission,
801#ifdef CONFIG_CIFS_XATTR
802 .setxattr = cifs_setxattr,
803 .getxattr = cifs_getxattr,
804 .listxattr = cifs_listxattr,
805 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000806#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807};
808
Arjan van de Ven754661f2007-02-12 00:55:38 -0800809const struct inode_operations cifs_symlink_inode_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000810 .readlink = generic_readlink,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 .follow_link = cifs_follow_link,
812 .put_link = cifs_put_link,
813 .permission = cifs_permission,
814 /* BB add the following two eventually */
815 /* revalidate: cifs_revalidate,
816 setattr: cifs_notify_change, *//* BB do we need notify change */
817#ifdef CONFIG_CIFS_XATTR
818 .setxattr = cifs_setxattr,
819 .getxattr = cifs_getxattr,
820 .listxattr = cifs_listxattr,
821 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000822#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823};
824
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800825const struct file_operations cifs_file_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800826 .read = do_sync_read,
827 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800828 .aio_read = generic_file_aio_read,
829 .aio_write = cifs_file_aio_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 .open = cifs_open,
831 .release = cifs_close,
832 .lock = cifs_lock,
833 .fsync = cifs_fsync,
834 .flush = cifs_flush,
835 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200836 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800837 .llseek = cifs_llseek,
Steve Frenchc67593a2005-04-28 22:41:04 -0700838#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000839 .unlocked_ioctl = cifs_ioctl,
Steve Frenchc67593a2005-04-28 22:41:04 -0700840#endif /* CONFIG_CIFS_POSIX */
Steve French84210e92008-10-23 04:42:37 +0000841 .setlease = cifs_setlease,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842};
843
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300844const struct file_operations cifs_file_strict_ops = {
845 .read = do_sync_read,
846 .write = do_sync_write,
Pavel Shilovskya70307e2010-12-14 11:50:41 +0300847 .aio_read = cifs_strict_readv,
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500848 .aio_write = cifs_strict_writev,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300849 .open = cifs_open,
850 .release = cifs_close,
851 .lock = cifs_lock,
852 .fsync = cifs_strict_fsync,
853 .flush = cifs_flush,
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +0300854 .mmap = cifs_file_strict_mmap,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300855 .splice_read = generic_file_splice_read,
856 .llseek = cifs_llseek,
857#ifdef CONFIG_CIFS_POSIX
858 .unlocked_ioctl = cifs_ioctl,
859#endif /* CONFIG_CIFS_POSIX */
860 .setlease = cifs_setlease,
861};
862
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800863const struct file_operations cifs_file_direct_ops = {
Pavel Shilovsky0b81c1c2011-03-10 10:11:05 +0300864 /* BB reevaluate whether they can be done with directio, no cache */
865 .read = do_sync_read,
866 .write = do_sync_write,
867 .aio_read = cifs_user_readv,
868 .aio_write = cifs_user_writev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 .open = cifs_open,
870 .release = cifs_close,
871 .lock = cifs_lock,
872 .fsync = cifs_fsync,
873 .flush = cifs_flush,
Steve Frencha994b8f2009-12-07 05:44:46 +0000874 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200875 .splice_read = generic_file_splice_read,
Steve Frenchc67593a2005-04-28 22:41:04 -0700876#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000877 .unlocked_ioctl = cifs_ioctl,
Steve Frenchc67593a2005-04-28 22:41:04 -0700878#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800879 .llseek = cifs_llseek,
Steve French84210e92008-10-23 04:42:37 +0000880 .setlease = cifs_setlease,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881};
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300882
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800883const struct file_operations cifs_file_nobrl_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800884 .read = do_sync_read,
885 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800886 .aio_read = generic_file_aio_read,
887 .aio_write = cifs_file_aio_write,
888 .open = cifs_open,
889 .release = cifs_close,
890 .fsync = cifs_fsync,
891 .flush = cifs_flush,
892 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200893 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800894 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800895#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000896 .unlocked_ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800897#endif /* CONFIG_CIFS_POSIX */
Steve French84210e92008-10-23 04:42:37 +0000898 .setlease = cifs_setlease,
Steve French8b94bcb2005-11-11 11:41:00 -0800899};
900
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300901const struct file_operations cifs_file_strict_nobrl_ops = {
902 .read = do_sync_read,
903 .write = do_sync_write,
Pavel Shilovskya70307e2010-12-14 11:50:41 +0300904 .aio_read = cifs_strict_readv,
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500905 .aio_write = cifs_strict_writev,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300906 .open = cifs_open,
907 .release = cifs_close,
908 .fsync = cifs_strict_fsync,
909 .flush = cifs_flush,
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +0300910 .mmap = cifs_file_strict_mmap,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300911 .splice_read = generic_file_splice_read,
912 .llseek = cifs_llseek,
913#ifdef CONFIG_CIFS_POSIX
914 .unlocked_ioctl = cifs_ioctl,
915#endif /* CONFIG_CIFS_POSIX */
916 .setlease = cifs_setlease,
917};
918
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800919const struct file_operations cifs_file_direct_nobrl_ops = {
Pavel Shilovsky0b81c1c2011-03-10 10:11:05 +0300920 /* BB reevaluate whether they can be done with directio, no cache */
921 .read = do_sync_read,
922 .write = do_sync_write,
923 .aio_read = cifs_user_readv,
924 .aio_write = cifs_user_writev,
Steve French87c89dd2005-11-17 17:03:00 -0800925 .open = cifs_open,
926 .release = cifs_close,
927 .fsync = cifs_fsync,
928 .flush = cifs_flush,
Pavel Shilovsky810627a02010-03-27 02:00:49 +0000929 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200930 .splice_read = generic_file_splice_read,
Steve French8b94bcb2005-11-11 11:41:00 -0800931#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000932 .unlocked_ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800933#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800934 .llseek = cifs_llseek,
Steve French84210e92008-10-23 04:42:37 +0000935 .setlease = cifs_setlease,
Steve French8b94bcb2005-11-11 11:41:00 -0800936};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800938const struct file_operations cifs_dir_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 .readdir = cifs_readdir,
940 .release = cifs_closedir,
941 .read = generic_read_dir,
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000942 .unlocked_ioctl = cifs_ioctl,
Christoph Hellwig3222a3e2008-09-03 21:53:01 +0200943 .llseek = generic_file_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944};
945
946static void
Alexey Dobriyan51cc5062008-07-25 19:45:34 -0700947cifs_init_once(void *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948{
949 struct cifsInodeInfo *cifsi = inode;
950
Christoph Lametera35afb82007-05-16 22:10:57 -0700951 inode_init_once(&cifsi->vfs_inode);
Pavel Shilovskyd59dad22011-09-22 09:53:59 +0400952 INIT_LIST_HEAD(&cifsi->llist);
953 mutex_init(&cifsi->lock_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954}
955
956static int
957cifs_init_inodecache(void)
958{
959 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
Steve French26f57362007-08-30 22:09:15 +0000960 sizeof(struct cifsInodeInfo),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800961 0, (SLAB_RECLAIM_ACCOUNT|
962 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +0900963 cifs_init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 if (cifs_inode_cachep == NULL)
965 return -ENOMEM;
966
967 return 0;
968}
969
970static void
971cifs_destroy_inodecache(void)
972{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700973 kmem_cache_destroy(cifs_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974}
975
976static int
977cifs_init_request_bufs(void)
978{
Steve French4523cc32007-04-30 20:13:06 +0000979 if (CIFSMaxBufSize < 8192) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
981 Unicode path name has to fit in any SMB/CIFS path based frames */
982 CIFSMaxBufSize = 8192;
983 } else if (CIFSMaxBufSize > 1024*127) {
984 CIFSMaxBufSize = 1024 * 127;
985 } else {
986 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
987 }
Joe Perchesb6b38f72010-04-21 03:50:45 +0000988/* cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 cifs_req_cachep = kmem_cache_create("cifs_request",
990 CIFSMaxBufSize +
991 MAX_CIFS_HDR_SIZE, 0,
Paul Mundt20c2df82007-07-20 10:11:58 +0900992 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 if (cifs_req_cachep == NULL)
994 return -ENOMEM;
995
Steve French4523cc32007-04-30 20:13:06 +0000996 if (cifs_min_rcv < 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 cifs_min_rcv = 1;
998 else if (cifs_min_rcv > 64) {
999 cifs_min_rcv = 64;
Joe Perchesb6b38f72010-04-21 03:50:45 +00001000 cERROR(1, "cifs_min_rcv set to maximum (64)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 }
1002
Matthew Dobson93d23412006-03-26 01:37:50 -08001003 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1004 cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005
Steve French4523cc32007-04-30 20:13:06 +00001006 if (cifs_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 kmem_cache_destroy(cifs_req_cachep);
1008 return -ENOMEM;
1009 }
Steve Frenchec637e32005-12-12 20:53:18 -08001010 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 almost all handle based requests (but not write response, nor is it
1012 sufficient for path based requests). A smaller size would have
Steve French50c2f752007-07-13 00:33:32 +00001013 been more efficient (compacting multiple slab items on one 4k page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 for the case in which debug was on, but this larger size allows
1015 more SMBs to use small buffer alloc and is still much more
Steve French6dc0f872007-07-06 23:13:06 +00001016 efficient to alloc 1 per page off the slab compared to 17K (5page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 alloc of large cifs buffers even when page debugging is on */
1018 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
Steve French6dc0f872007-07-06 23:13:06 +00001019 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +09001020 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 if (cifs_sm_req_cachep == NULL) {
1022 mempool_destroy(cifs_req_poolp);
1023 kmem_cache_destroy(cifs_req_cachep);
Steve French6dc0f872007-07-06 23:13:06 +00001024 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 }
1026
Steve French4523cc32007-04-30 20:13:06 +00001027 if (cifs_min_small < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 cifs_min_small = 2;
1029 else if (cifs_min_small > 256) {
1030 cifs_min_small = 256;
Joe Perchesb6b38f72010-04-21 03:50:45 +00001031 cFYI(1, "cifs_min_small set to maximum (256)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 }
1033
Matthew Dobson93d23412006-03-26 01:37:50 -08001034 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1035 cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036
Steve French4523cc32007-04-30 20:13:06 +00001037 if (cifs_sm_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 mempool_destroy(cifs_req_poolp);
1039 kmem_cache_destroy(cifs_req_cachep);
1040 kmem_cache_destroy(cifs_sm_req_cachep);
1041 return -ENOMEM;
1042 }
1043
1044 return 0;
1045}
1046
1047static void
1048cifs_destroy_request_bufs(void)
1049{
1050 mempool_destroy(cifs_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001051 kmem_cache_destroy(cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 mempool_destroy(cifs_sm_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001053 kmem_cache_destroy(cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054}
1055
1056static int
1057cifs_init_mids(void)
1058{
1059 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
Steve French26f57362007-08-30 22:09:15 +00001060 sizeof(struct mid_q_entry), 0,
1061 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 if (cifs_mid_cachep == NULL)
1063 return -ENOMEM;
1064
Matthew Dobson93d23412006-03-26 01:37:50 -08001065 /* 3 is a reasonable minimum number of simultaneous operations */
1066 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
Steve French4523cc32007-04-30 20:13:06 +00001067 if (cifs_mid_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 kmem_cache_destroy(cifs_mid_cachep);
1069 return -ENOMEM;
1070 }
1071
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 return 0;
1073}
1074
1075static void
1076cifs_destroy_mids(void)
1077{
1078 mempool_destroy(cifs_mid_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001079 kmem_cache_destroy(cifs_mid_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080}
1081
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082static int __init
1083init_cifs(void)
1084{
1085 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 cifs_proc_init();
Jeff Laytone7ddee92008-11-14 13:44:38 -05001087 INIT_LIST_HEAD(&cifs_tcp_ses_list);
Steve French0eff0e22011-02-24 05:39:23 +00001088#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
Steve French4ca9c192005-10-10 19:52:13 -07001089 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1090 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
Steve French0eff0e22011-02-24 05:39:23 +00001091#endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092/*
1093 * Initialize Global counters
1094 */
1095 atomic_set(&sesInfoAllocCount, 0);
1096 atomic_set(&tconInfoAllocCount, 0);
Steve French6dc0f872007-07-06 23:13:06 +00001097 atomic_set(&tcpSesAllocCount, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 atomic_set(&tcpSesReconnectCount, 0);
1099 atomic_set(&tconInfoReconnectCount, 0);
1100
1101 atomic_set(&bufAllocCount, 0);
Steve French4498eed52005-12-03 13:58:57 -08001102 atomic_set(&smBufAllocCount, 0);
1103#ifdef CONFIG_CIFS_STATS2
1104 atomic_set(&totBufAllocCount, 0);
1105 atomic_set(&totSmBufAllocCount, 0);
1106#endif /* CONFIG_CIFS_STATS2 */
1107
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 atomic_set(&midCount, 0);
1109 GlobalCurrentXid = 0;
1110 GlobalTotalActiveXid = 0;
1111 GlobalMaxActiveXid = 0;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301112 spin_lock_init(&cifs_tcp_ses_lock);
Jeff Layton44772882010-10-15 15:34:03 -04001113 spin_lock_init(&cifs_file_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 spin_lock_init(&GlobalMid_Lock);
1115
Steve French4523cc32007-04-30 20:13:06 +00001116 if (cifs_max_pending < 2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 cifs_max_pending = 2;
Joe Perchesb6b38f72010-04-21 03:50:45 +00001118 cFYI(1, "cifs_max_pending set to min of 2");
Steve French4523cc32007-04-30 20:13:06 +00001119 } else if (cifs_max_pending > 256) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 cifs_max_pending = 256;
Joe Perchesb6b38f72010-04-21 03:50:45 +00001121 cFYI(1, "cifs_max_pending set to max of 256");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 }
1123
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301124 rc = cifs_fscache_register();
1125 if (rc)
Steve Frenchd3bf5222010-09-22 19:15:36 +00001126 goto out_clean_proc;
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301127
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 rc = cifs_init_inodecache();
Steve French45af7a02006-04-21 22:52:25 +00001129 if (rc)
Steve Frenchd3bf5222010-09-22 19:15:36 +00001130 goto out_unreg_fscache;
Steve French45af7a02006-04-21 22:52:25 +00001131
1132 rc = cifs_init_mids();
1133 if (rc)
1134 goto out_destroy_inodecache;
1135
1136 rc = cifs_init_request_bufs();
1137 if (rc)
1138 goto out_destroy_mids;
1139
Jeff Layton84a15b92007-11-03 05:02:24 +00001140#ifdef CONFIG_CIFS_UPCALL
1141 rc = register_key_type(&cifs_spnego_key_type);
1142 if (rc)
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001143 goto out_destroy_request_bufs;
1144#endif /* CONFIG_CIFS_UPCALL */
1145
1146#ifdef CONFIG_CIFS_ACL
1147 rc = init_cifs_idmap();
1148 if (rc)
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001149 goto out_register_key_type;
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001150#endif /* CONFIG_CIFS_ACL */
1151
1152 rc = register_filesystem(&cifs_fs_type);
1153 if (rc)
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001154 goto out_init_cifs_idmap;
Steve French45af7a02006-04-21 22:52:25 +00001155
Steve French45af7a02006-04-21 22:52:25 +00001156 return 0;
1157
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001158out_init_cifs_idmap:
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001159#ifdef CONFIG_CIFS_ACL
1160 exit_cifs_idmap();
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001161out_register_key_type:
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001162#endif
1163#ifdef CONFIG_CIFS_UPCALL
1164 unregister_key_type(&cifs_spnego_key_type);
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001165out_destroy_request_bufs:
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001166#endif
Steve French45af7a02006-04-21 22:52:25 +00001167 cifs_destroy_request_bufs();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001168out_destroy_mids:
Steve French45af7a02006-04-21 22:52:25 +00001169 cifs_destroy_mids();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001170out_destroy_inodecache:
Steve French45af7a02006-04-21 22:52:25 +00001171 cifs_destroy_inodecache();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001172out_unreg_fscache:
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301173 cifs_fscache_unregister();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001174out_clean_proc:
1175 cifs_proc_clean();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 return rc;
1177}
1178
1179static void __exit
1180exit_cifs(void)
1181{
Joe Perchesb6b38f72010-04-21 03:50:45 +00001182 cFYI(DBG2, "exit_cifs");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 cifs_proc_clean();
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301184 cifs_fscache_unregister();
Steve French61033352008-01-09 16:21:36 +00001185#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov78d31a32008-04-24 12:56:07 +04001186 cifs_dfs_release_automount_timer();
Steve French61033352008-01-09 16:21:36 +00001187#endif
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001188#ifdef CONFIG_CIFS_ACL
1189 cifs_destroy_idmaptrees();
1190 exit_cifs_idmap();
1191#endif
Jeff Layton84a15b92007-11-03 05:02:24 +00001192#ifdef CONFIG_CIFS_UPCALL
1193 unregister_key_type(&cifs_spnego_key_type);
1194#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 unregister_filesystem(&cifs_fs_type);
1196 cifs_destroy_inodecache();
1197 cifs_destroy_mids();
1198 cifs_destroy_request_bufs();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199}
1200
1201MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
Steve French6dc0f872007-07-06 23:13:06 +00001202MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203MODULE_DESCRIPTION
Steve French63135e02007-07-17 17:34:02 +00001204 ("VFS to access servers complying with the SNIA CIFS Specification "
1205 "e.g. Samba and Windows");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206MODULE_VERSION(CIFS_VERSION);
1207module_init(init_cifs)
1208module_exit(exit_cifs)