blob: 9a6696a5eb782e76a6af8ead9028e8ab2b88383d [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>
Ben Greear3eb9a882010-09-01 17:06:02 -070038#include <net/ipv6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include "cifsfs.h"
40#include "cifspdu.h"
41#define DECLARE_GLOBALS_HERE
42#include "cifsglob.h"
43#include "cifsproto.h"
44#include "cifs_debug.h"
45#include "cifs_fs_sb.h"
46#include <linux/mm.h>
Jeff Layton84a15b92007-11-03 05:02:24 +000047#include <linux/key-type.h>
Jeff Laytone5459372007-11-03 05:11:06 +000048#include "cifs_spnego.h"
Suresh Jayaramanf579cf32010-07-05 18:11:50 +053049#include "fscache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
51
Linus Torvalds1da177e2005-04-16 15:20:36 -070052int cifsFYI = 0;
53int cifsERROR = 1;
54int traceSMB = 0;
55unsigned int oplockEnabled = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070056unsigned int linuxExtEnabled = 1;
57unsigned int lookupCacheEnabled = 1;
58unsigned int multiuser_mount = 0;
Jeff Layton04912d62010-04-24 07:57:45 -040059unsigned int global_secflags = CIFSSEC_DEF;
Steve French39798772006-05-31 22:40:51 +000060/* unsigned int ntlmv2_support = 0; */
Linus Torvalds1da177e2005-04-16 15:20:36 -070061unsigned int sign_CIFS_PDUs = 1;
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -080062static const struct super_operations cifs_super_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070063unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
64module_param(CIFSMaxBufSize, int, 0);
Steve French63135e02007-07-17 17:34:02 +000065MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
66 "Default: 16384 Range: 8192 to 130048");
Linus Torvalds1da177e2005-04-16 15:20:36 -070067unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
68module_param(cifs_min_rcv, int, 0);
Steve French63135e02007-07-17 17:34:02 +000069MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
70 "1 to 64");
Linus Torvalds1da177e2005-04-16 15:20:36 -070071unsigned int cifs_min_small = 30;
72module_param(cifs_min_small, int, 0);
Steve French63135e02007-07-17 17:34:02 +000073MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
74 "Range: 2 to 256");
Linus Torvalds1da177e2005-04-16 15:20:36 -070075unsigned int cifs_max_pending = CIFS_MAX_REQ;
76module_param(cifs_max_pending, int, 0);
Steve French63135e02007-07-17 17:34:02 +000077MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
78 "Default: 50 Range: 2 to 256");
Steve Frenchfda35942011-01-20 18:06:34 +000079unsigned short echo_retries = 5;
80module_param(echo_retries, ushort, 0644);
81MODULE_PARM_DESC(echo_retries, "Number of echo attempts before giving up and "
82 "reconnecting server. Default: 5. 0 means "
83 "never reconnect.");
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 Laytond7c86ff2010-10-11 15:07:19 -040088void
89cifs_sb_active(struct super_block *sb)
90{
91 struct cifs_sb_info *server = CIFS_SB(sb);
92
93 if (atomic_inc_return(&server->active) == 1)
94 atomic_inc(&sb->s_active);
95}
96
97void
98cifs_sb_deactive(struct super_block *sb)
99{
100 struct cifs_sb_info *server = CIFS_SB(sb);
101
102 if (atomic_dec_and_test(&server->active))
103 deactivate_super(sb);
104}
105
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106static int
Al Viro97d11522011-06-17 09:29:57 -0400107cifs_read_super(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108{
109 struct inode *inode;
Pavel Shilovskyb2e5cd32011-05-25 13:35:34 +0400110 struct cifs_sb_info *cifs_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +0000112
Pavel Shilovskyb2e5cd32011-05-25 13:35:34 +0400113 cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
Al Viro2c6292a2011-06-17 09:05:48 -0400115 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
116 sb->s_flags |= MS_POSIXACL;
117
118 if (cifs_sb_master_tcon(cifs_sb)->ses->capabilities & CAP_LARGE_FILES)
119 sb->s_maxbytes = MAX_LFS_FILESIZE;
120 else
121 sb->s_maxbytes = MAX_NON_LFS;
122
123 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
124 sb->s_time_gran = 100;
125
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 sb->s_magic = CIFS_MAGIC_NUMBER;
127 sb->s_op = &cifs_super_ops;
Jens Axboe8044f7f2010-04-22 12:09:48 +0200128 sb->s_bdi = &cifs_sb->bdi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 sb->s_blocksize = CIFS_MAX_MSGSIZE;
130 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
Shirish Pargaonkar9b6763e2011-02-21 23:56:59 -0600131 inode = cifs_root_iget(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
David Howellsce634ab2008-02-07 00:15:33 -0800133 if (IS_ERR(inode)) {
134 rc = PTR_ERR(inode);
135 inode = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 goto out_no_root;
137 }
138
139 sb->s_root = d_alloc_root(inode);
140
141 if (!sb->s_root) {
142 rc = -ENOMEM;
143 goto out_no_root;
144 }
Steve French50c2f752007-07-13 00:33:32 +0000145
Al Viro1c929cf2010-12-18 11:43:51 -0500146 /* do that *after* d_alloc_root() - we want NULL ->d_op for root here */
147 if (cifs_sb_master_tcon(cifs_sb)->nocase)
148 sb->s_d_op = &cifs_ci_dentry_ops;
149 else
150 sb->s_d_op = &cifs_dentry_ops;
151
Shirish Pargaonkar25720872011-02-25 10:48:55 -0600152#ifdef CIFS_NFSD_EXPORT
Steve French7521a3c2007-07-11 18:30:34 +0000153 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000154 cFYI(1, "export ops supported");
Steve French7521a3c2007-07-11 18:30:34 +0000155 sb->s_export_op = &cifs_export_ops;
156 }
Shirish Pargaonkar25720872011-02-25 10:48:55 -0600157#endif /* CIFS_NFSD_EXPORT */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
159 return 0;
160
161out_no_root:
Joe Perchesb6b38f72010-04-21 03:50:45 +0000162 cERROR(1, "cifs_read_super: get root inode failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 if (inode)
164 iput(inode);
Steve French54b46022008-08-11 22:31:40 +0000165
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 return rc;
167}
168
Al Viro6d686172011-06-17 08:34:57 -0400169static void cifs_kill_sb(struct super_block *sb)
170{
171 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
172 kill_anon_super(sb);
Al Viro98ab4942011-06-17 09:32:10 -0400173 cifs_umount(cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174}
175
176static int
David Howells726c3342006-06-23 02:02:58 -0700177cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178{
David Howells726c3342006-06-23 02:02:58 -0700179 struct super_block *sb = dentry->d_sb;
Steve French39da9842008-04-28 04:04:34 +0000180 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French96daf2b2011-05-27 04:34:02 +0000181 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Steve Frenchc81156d2005-04-28 22:41:07 -0700182 int rc = -EOPNOTSUPP;
Steve French39da9842008-04-28 04:04:34 +0000183 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
185 xid = GetXid();
186
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 buf->f_type = CIFS_MAGIC_NUMBER;
188
Steve French39da9842008-04-28 04:04:34 +0000189 /*
190 * PATH_MAX may be too long - it would presumably be total path,
191 * but note that some servers (includinng Samba 3) have a shorter
192 * maximum path.
193 *
194 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
195 */
196 buf->f_namelen = PATH_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 buf->f_files = 0; /* undefined */
198 buf->f_ffree = 0; /* unlimited */
199
Steve French39da9842008-04-28 04:04:34 +0000200 /*
201 * We could add a second check for a QFS Unix capability bit
202 */
203 if ((tcon->ses->capabilities & CAP_UNIX) &&
204 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
205 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
Steve French39da9842008-04-28 04:04:34 +0000207 /*
208 * Only need to call the old QFSInfo if failed on newer one,
209 * e.g. by OS/2.
210 **/
211 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
212 rc = CIFSSMBQFSInfo(xid, tcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Steve French39da9842008-04-28 04:04:34 +0000214 /*
215 * Some old Windows servers also do not support level 103, retry with
216 * older level one if old server failed the previous call or we
217 * bypassed it because we detected that this was an older LANMAN sess
218 */
Steve French4523cc32007-04-30 20:13:06 +0000219 if (rc)
Steve French39da9842008-04-28 04:04:34 +0000220 rc = SMBOldQFSInfo(xid, tcon, buf);
221
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 FreeXid(xid);
Steve French39da9842008-04-28 04:04:34 +0000223 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224}
225
Nick Pigginb74c79e2011-01-07 17:49:58 +1100226static int cifs_permission(struct inode *inode, int mask, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227{
228 struct cifs_sb_info *cifs_sb;
229
230 cifs_sb = CIFS_SB(inode->i_sb);
231
Miklos Szeredif696a362008-07-31 13:41:58 +0200232 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
233 if ((mask & MAY_EXEC) && !execute_ok(inode))
234 return -EACCES;
235 else
236 return 0;
237 } else /* file mode might have been restricted at mount time
Steve French50c2f752007-07-13 00:33:32 +0000238 on the client (above and beyond ACL on servers) for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 servers which do not support setting and viewing mode bits,
Steve French50c2f752007-07-13 00:33:32 +0000240 so allowing client to check permissions is useful */
Nick Pigginb74c79e2011-01-07 17:49:58 +1100241 return generic_permission(inode, mask, flags, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242}
243
Christoph Lametere18b8902006-12-06 20:33:20 -0800244static struct kmem_cache *cifs_inode_cachep;
245static struct kmem_cache *cifs_req_cachep;
246static struct kmem_cache *cifs_mid_cachep;
Christoph Lametere18b8902006-12-06 20:33:20 -0800247static struct kmem_cache *cifs_sm_req_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248mempool_t *cifs_sm_req_poolp;
249mempool_t *cifs_req_poolp;
250mempool_t *cifs_mid_poolp;
251
252static struct inode *
253cifs_alloc_inode(struct super_block *sb)
254{
255 struct cifsInodeInfo *cifs_inode;
Christoph Lametere94b1762006-12-06 20:33:17 -0800256 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 if (!cifs_inode)
258 return NULL;
259 cifs_inode->cifsAttrs = 0x20; /* default */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 cifs_inode->time = 0;
261 /* Until the file is open and we have gotten oplock
262 info back from the server, can not assume caching of
263 file data or metadata */
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300264 cifs_set_oplock_level(cifs_inode, 0);
Jeff Layton9a8165f2008-10-17 21:03:20 -0400265 cifs_inode->delete_pending = false;
Jeff Laytondf2cf172010-02-12 07:44:16 -0500266 cifs_inode->invalid_mapping = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400268 cifs_inode->server_eof = 0;
Jeff Layton20054bd2011-01-07 11:30:27 -0500269 cifs_inode->uniqueid = 0;
270 cifs_inode->createtime = 0;
Steve French50c2f752007-07-13 00:33:32 +0000271
Steve French1b2b2122007-02-17 04:30:54 +0000272 /* Can not set i_flags here - they get immediately overwritten
273 to zero by the VFS */
274/* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 INIT_LIST_HEAD(&cifs_inode->openFileList);
276 return &cifs_inode->vfs_inode;
277}
278
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100279static void cifs_i_callback(struct rcu_head *head)
280{
281 struct inode *inode = container_of(head, struct inode, i_rcu);
282 INIT_LIST_HEAD(&inode->i_dentry);
283 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
284}
285
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286static void
287cifs_destroy_inode(struct inode *inode)
288{
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100289 call_rcu(&inode->i_rcu, cifs_i_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290}
291
Jeff Layton61f98ff2009-06-11 10:27:32 -0400292static void
Al Virob57922d2010-06-07 14:34:48 -0400293cifs_evict_inode(struct inode *inode)
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530294{
Al Virob57922d2010-06-07 14:34:48 -0400295 truncate_inode_pages(&inode->i_data, 0);
296 end_writeback(inode);
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530297 cifs_fscache_release_inode_cookie(inode);
298}
299
300static void
Jeff Layton61f98ff2009-06-11 10:27:32 -0400301cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
302{
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300303 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
304 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
305
Jeff Layton61f98ff2009-06-11 10:27:32 -0400306 seq_printf(s, ",addr=");
307
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300308 switch (server->dstaddr.ss_family) {
Jeff Layton61f98ff2009-06-11 10:27:32 -0400309 case AF_INET:
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300310 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
Jeff Layton61f98ff2009-06-11 10:27:32 -0400311 break;
312 case AF_INET6:
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300313 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
314 if (sa6->sin6_scope_id)
315 seq_printf(s, "%%%u", sa6->sin6_scope_id);
Jeff Layton61f98ff2009-06-11 10:27:32 -0400316 break;
317 default:
318 seq_printf(s, "(unknown)");
319 }
320}
321
Jeff Layton3e715512011-06-13 11:50:41 -0400322static void
323cifs_show_security(struct seq_file *s, struct TCP_Server_Info *server)
324{
325 seq_printf(s, ",sec=");
326
327 switch (server->secType) {
328 case LANMAN:
329 seq_printf(s, "lanman");
330 break;
331 case NTLMv2:
332 seq_printf(s, "ntlmv2");
333 break;
334 case NTLM:
335 seq_printf(s, "ntlm");
336 break;
337 case Kerberos:
338 seq_printf(s, "krb5");
339 break;
340 case RawNTLMSSP:
341 seq_printf(s, "ntlmssp");
342 break;
343 default:
344 /* shouldn't ever happen */
345 seq_printf(s, "unknown");
346 break;
347 }
348
349 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
350 seq_printf(s, "i");
351}
352
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353/*
354 * cifs_show_options() is for displaying mount options in /proc/mounts.
355 * Not all settable options are displayed but most of the important
356 * ones are.
357 */
358static int
359cifs_show_options(struct seq_file *s, struct vfsmount *m)
360{
Jeff Layton8e047d02009-08-28 10:11:10 -0400361 struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
Steve French96daf2b2011-05-27 04:34:02 +0000362 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Ben Greear3eb9a882010-09-01 17:06:02 -0700363 struct sockaddr *srcaddr;
364 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
Jeff Layton3e715512011-06-13 11:50:41 -0400366 cifs_show_security(s, tcon->ses->server);
367
Jeff Layton8e047d02009-08-28 10:11:10 -0400368 seq_printf(s, ",unc=%s", tcon->treeName);
Jeff Layton29e07c82010-09-29 19:51:12 -0400369
370 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
371 seq_printf(s, ",multiuser");
Steve French8727c8a2011-02-25 01:11:56 -0600372 else if (tcon->ses->user_name)
373 seq_printf(s, ",username=%s", tcon->ses->user_name);
Jeff Layton29e07c82010-09-29 19:51:12 -0400374
Jeff Layton8616e0f2009-06-11 10:27:28 -0400375 if (tcon->ses->domainName)
376 seq_printf(s, ",domain=%s", tcon->ses->domainName);
377
Ben Greear3eb9a882010-09-01 17:06:02 -0700378 if (srcaddr->sa_family != AF_UNSPEC) {
379 struct sockaddr_in *saddr4;
380 struct sockaddr_in6 *saddr6;
381 saddr4 = (struct sockaddr_in *)srcaddr;
382 saddr6 = (struct sockaddr_in6 *)srcaddr;
383 if (srcaddr->sa_family == AF_INET6)
384 seq_printf(s, ",srcaddr=%pI6c",
385 &saddr6->sin6_addr);
386 else if (srcaddr->sa_family == AF_INET)
387 seq_printf(s, ",srcaddr=%pI4",
388 &saddr4->sin_addr.s_addr);
389 else
390 seq_printf(s, ",srcaddr=BAD-AF:%i",
391 (int)(srcaddr->sa_family));
392 }
393
Jeff Layton8616e0f2009-06-11 10:27:28 -0400394 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
Jeff Layton340481a32009-06-11 10:27:29 -0400395 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
396 seq_printf(s, ",forceuid");
Jeff Layton4486d6e2009-08-03 12:45:10 -0400397 else
398 seq_printf(s, ",noforceuid");
Jeff Layton340481a32009-06-11 10:27:29 -0400399
Jeff Layton8616e0f2009-06-11 10:27:28 -0400400 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
Jeff Layton340481a32009-06-11 10:27:29 -0400401 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
402 seq_printf(s, ",forcegid");
Jeff Layton4486d6e2009-08-03 12:45:10 -0400403 else
404 seq_printf(s, ",noforcegid");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400405
Jeff Layton61f98ff2009-06-11 10:27:32 -0400406 cifs_show_address(s, tcon->ses->server);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400407
408 if (!tcon->unix_ext)
409 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
Steve French2b280fa2008-05-17 03:12:45 +0000410 cifs_sb->mnt_file_mode,
411 cifs_sb->mnt_dir_mode);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400412 if (tcon->seal)
413 seq_printf(s, ",seal");
414 if (tcon->nocase)
415 seq_printf(s, ",nocase");
416 if (tcon->retry)
417 seq_printf(s, ",hard");
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000418 if (tcon->unix_ext)
419 seq_printf(s, ",unix");
420 else
421 seq_printf(s, ",nounix");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400422 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
423 seq_printf(s, ",posixpaths");
424 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
425 seq_printf(s, ",setuids");
426 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
427 seq_printf(s, ",serverino");
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000428 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
429 seq_printf(s, ",rwpidforward");
430 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
431 seq_printf(s, ",forcemand");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400432 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
433 seq_printf(s, ",directio");
434 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
435 seq_printf(s, ",nouser_xattr");
436 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
437 seq_printf(s, ",mapchars");
438 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
439 seq_printf(s, ",sfu");
440 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
441 seq_printf(s, ",nobrl");
442 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
443 seq_printf(s, ",cifsacl");
444 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
445 seq_printf(s, ",dynperm");
446 if (m->mnt_sb->s_flags & MS_POSIXACL)
447 seq_printf(s, ",acl");
Stefan Metzmacher736a3322010-07-30 14:56:00 +0200448 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
449 seq_printf(s, ",mfsymlinks");
Suresh Jayaraman476428f2010-11-24 17:49:07 +0530450 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
451 seq_printf(s, ",fsc");
Steve French2b280fa2008-05-17 03:12:45 +0000452
Jeff Layton8616e0f2009-06-11 10:27:28 -0400453 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
454 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
Suresh Jayaraman6d20e842010-12-01 14:42:28 +0530455 /* convert actimeo and display it in seconds */
456 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400457
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 return 0;
459}
460
Al Viro42faad92008-04-24 07:21:56 -0400461static void cifs_umount_begin(struct super_block *sb)
Steve French68058e72005-10-10 10:34:22 -0700462{
Al Viro42faad92008-04-24 07:21:56 -0400463 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French96daf2b2011-05-27 04:34:02 +0000464 struct cifs_tcon *tcon;
Steve French68058e72005-10-10 10:34:22 -0700465
Steve French4523cc32007-04-30 20:13:06 +0000466 if (cifs_sb == NULL)
Steve French9e2e85f2005-10-10 14:28:38 -0700467 return;
468
Jeff Layton0d424ad2010-09-20 16:01:35 -0700469 tcon = cifs_sb_master_tcon(cifs_sb);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500470
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530471 spin_lock(&cifs_tcp_ses_lock);
Steve Frenchad8034f2009-06-26 03:25:49 +0000472 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
473 /* we have other mounts to same share or we have
474 already tried to force umount this and woken up
475 all waiting network requests, nothing to do */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530476 spin_unlock(&cifs_tcp_ses_lock);
Steve Frenchad8034f2009-06-26 03:25:49 +0000477 return;
478 } else if (tcon->tc_count == 1)
Steve French5e1253b2005-10-10 14:06:37 -0700479 tcon->tidStatus = CifsExiting;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530480 spin_unlock(&cifs_tcp_ses_lock);
Steve French5e1253b2005-10-10 14:06:37 -0700481
Steve French3a5ff612006-07-14 22:37:11 +0000482 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
Steve French7b7abfe2005-11-09 15:21:09 -0800483 /* cancel_notify_requests(tcon); */
Steve French50c2f752007-07-13 00:33:32 +0000484 if (tcon->ses && tcon->ses->server) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000485 cFYI(1, "wake up tasks now - umount begin not complete");
Steve French9e2e85f2005-10-10 14:28:38 -0700486 wake_up_all(&tcon->ses->server->request_q);
Steve French6ab16d22005-11-29 20:55:11 -0800487 wake_up_all(&tcon->ses->server->response_q);
488 msleep(1); /* yield */
489 /* we have to kick the requests once more */
490 wake_up_all(&tcon->ses->server->response_q);
491 msleep(1);
Steve French5e1253b2005-10-10 14:06:37 -0700492 }
Steve French68058e72005-10-10 10:34:22 -0700493
494 return;
495}
Steve French68058e72005-10-10 10:34:22 -0700496
Steve Frenchbf97d282006-09-28 21:34:06 +0000497#ifdef CONFIG_CIFS_STATS2
498static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
499{
500 /* BB FIXME */
501 return 0;
502}
503#endif
504
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505static int cifs_remount(struct super_block *sb, int *flags, char *data)
506{
507 *flags |= MS_NODIRATIME;
508 return 0;
509}
510
Al Viro45321ac2010-06-07 13:43:19 -0400511static int cifs_drop_inode(struct inode *inode)
Jeff Layton12420ac2010-06-01 14:47:40 -0400512{
513 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
514
Al Viro45321ac2010-06-07 13:43:19 -0400515 /* no serverino => unconditional eviction */
516 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
517 generic_drop_inode(inode);
Jeff Layton12420ac2010-06-01 14:47:40 -0400518}
519
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800520static const struct super_operations cifs_super_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 .statfs = cifs_statfs,
522 .alloc_inode = cifs_alloc_inode,
523 .destroy_inode = cifs_destroy_inode,
Jeff Layton12420ac2010-06-01 14:47:40 -0400524 .drop_inode = cifs_drop_inode,
Al Virob57922d2010-06-07 14:34:48 -0400525 .evict_inode = cifs_evict_inode,
Jeff Layton12420ac2010-06-01 14:47:40 -0400526/* .delete_inode = cifs_delete_inode, */ /* Do not need above
527 function unless later we add lazy close of inodes or unless the
Steve French50c2f752007-07-13 00:33:32 +0000528 kernel forgets to call us with the same number of releases (closes)
529 as opens */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 .show_options = cifs_show_options,
Steve French7b7abfe2005-11-09 15:21:09 -0800531 .umount_begin = cifs_umount_begin,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 .remount_fs = cifs_remount,
Steve Frenchbf97d282006-09-28 21:34:06 +0000533#ifdef CONFIG_CIFS_STATS2
Steve Frenchf46d3e12006-09-30 01:08:55 +0000534 .show_stats = cifs_show_stats,
Steve Frenchbf97d282006-09-28 21:34:06 +0000535#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536};
537
Steve Frenchf87d39d2011-05-27 03:50:55 +0000538/*
539 * Get root dentry from superblock according to prefix path mount option.
540 * Return dentry with refcount + 1 on success and NULL otherwise.
541 */
542static struct dentry *
543cifs_get_root(struct smb_vol *vol, struct super_block *sb)
544{
545 int xid, rc;
546 struct inode *inode;
547 struct qstr name;
548 struct dentry *dparent = NULL, *dchild = NULL, *alias;
549 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
550 unsigned int i, full_len, len;
551 char *full_path = NULL, *pstart;
552 char sep;
553
554 full_path = cifs_build_path_to_root(vol, cifs_sb,
555 cifs_sb_master_tcon(cifs_sb));
556 if (full_path == NULL)
557 return NULL;
558
559 cFYI(1, "Get root dentry for %s", full_path);
560
561 xid = GetXid();
562 sep = CIFS_DIR_SEP(cifs_sb);
563 dparent = dget(sb->s_root);
564 full_len = strlen(full_path);
565 full_path[full_len] = sep;
566 pstart = full_path + 1;
567
568 for (i = 1, len = 0; i <= full_len; i++) {
569 if (full_path[i] != sep || !len) {
570 len++;
571 continue;
572 }
573
574 full_path[i] = 0;
575 cFYI(1, "get dentry for %s", pstart);
576
577 name.name = pstart;
578 name.len = len;
579 name.hash = full_name_hash(pstart, len);
580 dchild = d_lookup(dparent, &name);
581 if (dchild == NULL) {
582 cFYI(1, "not exists");
583 dchild = d_alloc(dparent, &name);
584 if (dchild == NULL) {
585 dput(dparent);
586 dparent = NULL;
587 goto out;
588 }
589 }
590
591 cFYI(1, "get inode");
592 if (dchild->d_inode == NULL) {
593 cFYI(1, "not exists");
594 inode = NULL;
595 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
596 rc = cifs_get_inode_info_unix(&inode, full_path,
597 sb, xid);
598 else
599 rc = cifs_get_inode_info(&inode, full_path,
600 NULL, sb, xid, NULL);
601 if (rc) {
602 dput(dchild);
603 dput(dparent);
604 dparent = NULL;
605 goto out;
606 }
607 alias = d_materialise_unique(dchild, inode);
608 if (alias != NULL) {
609 dput(dchild);
610 if (IS_ERR(alias)) {
611 dput(dparent);
612 dparent = NULL;
613 goto out;
614 }
615 dchild = alias;
616 }
617 }
618 cFYI(1, "parent %p, child %p", dparent, dchild);
619
620 dput(dparent);
621 dparent = dchild;
622 len = 0;
623 pstart = full_path + i + 1;
624 full_path[i] = sep;
625 }
626out:
627 _FreeXid(xid);
628 kfree(full_path);
629 return dparent;
630}
631
Al Viroee01a142011-06-17 09:47:23 -0400632static int cifs_set_super(struct super_block *sb, void *data)
633{
634 struct cifs_mnt_data *mnt_data = data;
635 sb->s_fs_info = mnt_data->cifs_sb;
636 return set_anon_super(sb, NULL);
637}
638
Al Virod753ed92010-07-26 12:52:33 +0400639static struct dentry *
640cifs_do_mount(struct file_system_type *fs_type,
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000641 int flags, const char *dev_name, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642{
643 int rc;
Jan Blunckdb719222010-08-15 22:51:10 +0200644 struct super_block *sb;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000645 struct cifs_sb_info *cifs_sb;
646 struct smb_vol *volume_info;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400647 struct cifs_mnt_data mnt_data;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000648 struct dentry *root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649
Joe Perchesb6b38f72010-04-21 03:50:45 +0000650 cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000652 rc = cifs_setup_volume_info(&volume_info, (char *)data, dev_name);
653 if (rc)
654 return ERR_PTR(rc);
655
656 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
657 if (cifs_sb == NULL) {
658 root = ERR_PTR(-ENOMEM);
Al Viro5c4f1ad2011-06-17 09:56:55 -0400659 goto out_nls;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000660 }
661
Al Viro5d3bc602011-06-17 09:17:28 -0400662 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
663 if (cifs_sb->mountdata == NULL) {
664 root = ERR_PTR(-ENOMEM);
Al Viro5c4f1ad2011-06-17 09:56:55 -0400665 goto out_cifs_sb;
Al Viro5d3bc602011-06-17 09:17:28 -0400666 }
667
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000668 cifs_setup_cifs_sb(volume_info, cifs_sb);
669
Al Viro97d11522011-06-17 09:29:57 -0400670 rc = cifs_mount(cifs_sb, volume_info);
671 if (rc) {
672 if (!(flags & MS_SILENT))
673 cERROR(1, "cifs_mount failed w/return code = %d", rc);
674 root = ERR_PTR(rc);
Al Viro5c4f1ad2011-06-17 09:56:55 -0400675 goto out_mountdata;
Al Viro97d11522011-06-17 09:29:57 -0400676 }
677
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400678 mnt_data.vol = volume_info;
679 mnt_data.cifs_sb = cifs_sb;
680 mnt_data.flags = flags;
681
Al Viroee01a142011-06-17 09:47:23 -0400682 sb = sget(fs_type, cifs_match_super, cifs_set_super, &mnt_data);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000683 if (IS_ERR(sb)) {
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000684 root = ERR_CAST(sb);
Al Viro97d11522011-06-17 09:29:57 -0400685 cifs_umount(cifs_sb);
Al Virod757d712011-06-17 09:42:43 -0400686 goto out;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000687 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
Al Viroee01a142011-06-17 09:47:23 -0400689 if (sb->s_root) {
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400690 cFYI(1, "Use existing superblock");
Al Viro97d11522011-06-17 09:29:57 -0400691 cifs_umount(cifs_sb);
Al Viro5c4f1ad2011-06-17 09:56:55 -0400692 } else {
693 sb->s_flags = flags;
694 /* BB should we make this contingent on mount parm? */
695 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
696
697 rc = cifs_read_super(sb);
698 if (rc) {
699 root = ERR_PTR(rc);
700 goto out_super;
701 }
702
703 sb->s_flags |= MS_ACTIVE;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400704 }
705
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400706 root = cifs_get_root(volume_info, sb);
Al Virofa18f1b2011-06-17 09:50:44 -0400707 if (root == NULL) {
708 root = ERR_PTR(-EINVAL); /* XXX */
709 goto out_super;
710 }
711
712 cFYI(1, "dentry root is: %p", root);
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400713 goto out;
714
Pavel Shilovsky641a58d2011-05-26 00:02:16 +0400715out_super:
Pavel Shilovsky641a58d2011-05-26 00:02:16 +0400716 deactivate_locked_super(sb);
Pavel Shilovsky641a58d2011-05-26 00:02:16 +0400717out:
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000718 cifs_cleanup_volume_info(&volume_info);
719 return root;
Al Viro5c4f1ad2011-06-17 09:56:55 -0400720
721out_mountdata:
722 kfree(cifs_sb->mountdata);
723out_cifs_sb:
724 kfree(cifs_sb);
725out_nls:
726 unload_nls(volume_info->local_nls);
727 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728}
729
Badari Pulavarty027445c2006-09-30 23:28:46 -0700730static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
731 unsigned long nr_segs, loff_t pos)
Steve French87c89dd2005-11-17 17:03:00 -0800732{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800733 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
Steve French87c89dd2005-11-17 17:03:00 -0800734 ssize_t written;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500735 int rc;
Steve French87c89dd2005-11-17 17:03:00 -0800736
Badari Pulavarty027445c2006-09-30 23:28:46 -0700737 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500738
739 if (CIFS_I(inode)->clientCanCacheAll)
740 return written;
741
742 rc = filemap_fdatawrite(inode->i_mapping);
743 if (rc)
744 cFYI(1, "cifs_file_aio_write: %d rc on %p inode", rc, inode);
745
Steve French87c89dd2005-11-17 17:03:00 -0800746 return written;
747}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748
Steve Frenchc32a0b62006-01-12 14:41:28 -0800749static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
750{
751 /* origin == SEEK_END => we must revalidate the cached file length */
Steve French0889a942006-09-23 22:11:07 +0000752 if (origin == SEEK_END) {
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400753 int rc;
754 struct inode *inode = file->f_path.dentry->d_inode;
Steve French030e9d82007-02-01 04:27:59 +0000755
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400756 /*
757 * We need to be sure that all dirty pages are written and the
758 * server has the newest file length.
759 */
760 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
761 inode->i_mapping->nrpages != 0) {
762 rc = filemap_fdatawait(inode->i_mapping);
Steve French156ecb22011-05-20 17:00:01 +0000763 if (rc) {
764 mapping_set_error(inode->i_mapping, rc);
765 return rc;
766 }
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400767 }
768 /*
769 * Some applications poll for the file length in this strange
770 * way so we must seek to end on non-oplocked files by
771 * setting the revalidate time to zero.
772 */
773 CIFS_I(inode)->time = 0;
Steve French030e9d82007-02-01 04:27:59 +0000774
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400775 rc = cifs_revalidate_file_attr(file);
776 if (rc < 0)
777 return (loff_t)rc;
Steve Frenchc32a0b62006-01-12 14:41:28 -0800778 }
Andi Kleen9465efc2008-06-27 11:05:24 +0200779 return generic_file_llseek_unlocked(file, offset, origin);
Steve Frenchc32a0b62006-01-12 14:41:28 -0800780}
781
Steve French84210e92008-10-23 04:42:37 +0000782static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
783{
Arnd Bergmannb89f4322010-09-18 15:09:31 +0200784 /* note that this is called by vfs setlease with lock_flocks held
785 to protect *lease from going away */
Steve French84210e92008-10-23 04:42:37 +0000786 struct inode *inode = file->f_path.dentry->d_inode;
Jeff Laytonba00ba62010-09-20 16:01:31 -0700787 struct cifsFileInfo *cfile = file->private_data;
Steve French84210e92008-10-23 04:42:37 +0000788
789 if (!(S_ISREG(inode->i_mode)))
790 return -EINVAL;
791
792 /* check if file is oplocked */
793 if (((arg == F_RDLCK) &&
794 (CIFS_I(inode)->clientCanCacheRead)) ||
795 ((arg == F_WRLCK) &&
796 (CIFS_I(inode)->clientCanCacheAll)))
797 return generic_setlease(file, arg, lease);
Jeff Layton13cfb732010-09-29 19:51:11 -0400798 else if (tlink_tcon(cfile->tlink)->local_lease &&
799 !CIFS_I(inode)->clientCanCacheRead)
Steve French84210e92008-10-23 04:42:37 +0000800 /* If the server claims to support oplock on this
801 file, then we still need to check oplock even
802 if the local_lease mount option is set, but there
803 are servers which do not support oplock for which
804 this mount option may be useful if the user
805 knows that the file won't be changed on the server
806 by anyone else */
807 return generic_setlease(file, arg, lease);
Christoph Hellwig51ee4b82010-10-31 08:35:10 -0400808 else
Steve French84210e92008-10-23 04:42:37 +0000809 return -EAGAIN;
810}
Steve French84210e92008-10-23 04:42:37 +0000811
Igor Mammedove6ab1582008-01-11 01:49:48 +0000812struct file_system_type cifs_fs_type = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 .owner = THIS_MODULE,
814 .name = "cifs",
Al Virod753ed92010-07-26 12:52:33 +0400815 .mount = cifs_do_mount,
Al Viro6d686172011-06-17 08:34:57 -0400816 .kill_sb = cifs_kill_sb,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 /* .fs_flags */
818};
Arjan van de Ven754661f2007-02-12 00:55:38 -0800819const struct inode_operations cifs_dir_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 .create = cifs_create,
821 .lookup = cifs_lookup,
822 .getattr = cifs_getattr,
823 .unlink = cifs_unlink,
824 .link = cifs_hardlink,
825 .mkdir = cifs_mkdir,
826 .rmdir = cifs_rmdir,
827 .rename = cifs_rename,
828 .permission = cifs_permission,
829/* revalidate:cifs_revalidate, */
830 .setattr = cifs_setattr,
831 .symlink = cifs_symlink,
832 .mknod = cifs_mknod,
833#ifdef CONFIG_CIFS_XATTR
834 .setxattr = cifs_setxattr,
835 .getxattr = cifs_getxattr,
836 .listxattr = cifs_listxattr,
837 .removexattr = cifs_removexattr,
838#endif
839};
840
Arjan van de Ven754661f2007-02-12 00:55:38 -0800841const struct inode_operations cifs_file_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842/* revalidate:cifs_revalidate, */
843 .setattr = cifs_setattr,
844 .getattr = cifs_getattr, /* do we need this anymore? */
845 .rename = cifs_rename,
846 .permission = cifs_permission,
847#ifdef CONFIG_CIFS_XATTR
848 .setxattr = cifs_setxattr,
849 .getxattr = cifs_getxattr,
850 .listxattr = cifs_listxattr,
851 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000852#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853};
854
Arjan van de Ven754661f2007-02-12 00:55:38 -0800855const struct inode_operations cifs_symlink_inode_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000856 .readlink = generic_readlink,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 .follow_link = cifs_follow_link,
858 .put_link = cifs_put_link,
859 .permission = cifs_permission,
860 /* BB add the following two eventually */
861 /* revalidate: cifs_revalidate,
862 setattr: cifs_notify_change, *//* BB do we need notify change */
863#ifdef CONFIG_CIFS_XATTR
864 .setxattr = cifs_setxattr,
865 .getxattr = cifs_getxattr,
866 .listxattr = cifs_listxattr,
867 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000868#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869};
870
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800871const struct file_operations cifs_file_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800872 .read = do_sync_read,
873 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800874 .aio_read = generic_file_aio_read,
875 .aio_write = cifs_file_aio_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 .open = cifs_open,
877 .release = cifs_close,
878 .lock = cifs_lock,
879 .fsync = cifs_fsync,
880 .flush = cifs_flush,
881 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200882 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800883 .llseek = cifs_llseek,
Steve Frenchc67593a2005-04-28 22:41:04 -0700884#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000885 .unlocked_ioctl = cifs_ioctl,
Steve Frenchc67593a2005-04-28 22:41:04 -0700886#endif /* CONFIG_CIFS_POSIX */
Steve French84210e92008-10-23 04:42:37 +0000887 .setlease = cifs_setlease,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888};
889
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300890const struct file_operations cifs_file_strict_ops = {
891 .read = do_sync_read,
892 .write = do_sync_write,
Pavel Shilovskya70307e2010-12-14 11:50:41 +0300893 .aio_read = cifs_strict_readv,
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500894 .aio_write = cifs_strict_writev,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300895 .open = cifs_open,
896 .release = cifs_close,
897 .lock = cifs_lock,
898 .fsync = cifs_strict_fsync,
899 .flush = cifs_flush,
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +0300900 .mmap = cifs_file_strict_mmap,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300901 .splice_read = generic_file_splice_read,
902 .llseek = cifs_llseek,
903#ifdef CONFIG_CIFS_POSIX
904 .unlocked_ioctl = cifs_ioctl,
905#endif /* CONFIG_CIFS_POSIX */
906 .setlease = cifs_setlease,
907};
908
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800909const struct file_operations cifs_file_direct_ops = {
Pavel Shilovsky0b81c1c2011-03-10 10:11:05 +0300910 /* BB reevaluate whether they can be done with directio, no cache */
911 .read = do_sync_read,
912 .write = do_sync_write,
913 .aio_read = cifs_user_readv,
914 .aio_write = cifs_user_writev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 .open = cifs_open,
916 .release = cifs_close,
917 .lock = cifs_lock,
918 .fsync = cifs_fsync,
919 .flush = cifs_flush,
Steve Frencha994b8f2009-12-07 05:44:46 +0000920 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200921 .splice_read = generic_file_splice_read,
Steve Frenchc67593a2005-04-28 22:41:04 -0700922#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000923 .unlocked_ioctl = cifs_ioctl,
Steve Frenchc67593a2005-04-28 22:41:04 -0700924#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800925 .llseek = cifs_llseek,
Steve French84210e92008-10-23 04:42:37 +0000926 .setlease = cifs_setlease,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927};
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300928
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800929const struct file_operations cifs_file_nobrl_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800930 .read = do_sync_read,
931 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800932 .aio_read = generic_file_aio_read,
933 .aio_write = cifs_file_aio_write,
934 .open = cifs_open,
935 .release = cifs_close,
936 .fsync = cifs_fsync,
937 .flush = cifs_flush,
938 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200939 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800940 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800941#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000942 .unlocked_ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800943#endif /* CONFIG_CIFS_POSIX */
Steve French84210e92008-10-23 04:42:37 +0000944 .setlease = cifs_setlease,
Steve French8b94bcb2005-11-11 11:41:00 -0800945};
946
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300947const struct file_operations cifs_file_strict_nobrl_ops = {
948 .read = do_sync_read,
949 .write = do_sync_write,
Pavel Shilovskya70307e2010-12-14 11:50:41 +0300950 .aio_read = cifs_strict_readv,
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500951 .aio_write = cifs_strict_writev,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300952 .open = cifs_open,
953 .release = cifs_close,
954 .fsync = cifs_strict_fsync,
955 .flush = cifs_flush,
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +0300956 .mmap = cifs_file_strict_mmap,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300957 .splice_read = generic_file_splice_read,
958 .llseek = cifs_llseek,
959#ifdef CONFIG_CIFS_POSIX
960 .unlocked_ioctl = cifs_ioctl,
961#endif /* CONFIG_CIFS_POSIX */
962 .setlease = cifs_setlease,
963};
964
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800965const struct file_operations cifs_file_direct_nobrl_ops = {
Pavel Shilovsky0b81c1c2011-03-10 10:11:05 +0300966 /* BB reevaluate whether they can be done with directio, no cache */
967 .read = do_sync_read,
968 .write = do_sync_write,
969 .aio_read = cifs_user_readv,
970 .aio_write = cifs_user_writev,
Steve French87c89dd2005-11-17 17:03:00 -0800971 .open = cifs_open,
972 .release = cifs_close,
973 .fsync = cifs_fsync,
974 .flush = cifs_flush,
Pavel Shilovsky810627a02010-03-27 02:00:49 +0000975 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200976 .splice_read = generic_file_splice_read,
Steve French8b94bcb2005-11-11 11:41:00 -0800977#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000978 .unlocked_ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800979#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800980 .llseek = cifs_llseek,
Steve French84210e92008-10-23 04:42:37 +0000981 .setlease = cifs_setlease,
Steve French8b94bcb2005-11-11 11:41:00 -0800982};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800984const struct file_operations cifs_dir_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 .readdir = cifs_readdir,
986 .release = cifs_closedir,
987 .read = generic_read_dir,
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000988 .unlocked_ioctl = cifs_ioctl,
Christoph Hellwig3222a3e2008-09-03 21:53:01 +0200989 .llseek = generic_file_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990};
991
992static void
Alexey Dobriyan51cc5062008-07-25 19:45:34 -0700993cifs_init_once(void *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994{
995 struct cifsInodeInfo *cifsi = inode;
996
Christoph Lametera35afb82007-05-16 22:10:57 -0700997 inode_init_once(&cifsi->vfs_inode);
998 INIT_LIST_HEAD(&cifsi->lockList);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999}
1000
1001static int
1002cifs_init_inodecache(void)
1003{
1004 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
Steve French26f57362007-08-30 22:09:15 +00001005 sizeof(struct cifsInodeInfo),
Paul Jacksonfffb60f2006-03-24 03:16:06 -08001006 0, (SLAB_RECLAIM_ACCOUNT|
1007 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +09001008 cifs_init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 if (cifs_inode_cachep == NULL)
1010 return -ENOMEM;
1011
1012 return 0;
1013}
1014
1015static void
1016cifs_destroy_inodecache(void)
1017{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001018 kmem_cache_destroy(cifs_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019}
1020
1021static int
1022cifs_init_request_bufs(void)
1023{
Steve French4523cc32007-04-30 20:13:06 +00001024 if (CIFSMaxBufSize < 8192) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1026 Unicode path name has to fit in any SMB/CIFS path based frames */
1027 CIFSMaxBufSize = 8192;
1028 } else if (CIFSMaxBufSize > 1024*127) {
1029 CIFSMaxBufSize = 1024 * 127;
1030 } else {
1031 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1032 }
Joe Perchesb6b38f72010-04-21 03:50:45 +00001033/* cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 cifs_req_cachep = kmem_cache_create("cifs_request",
1035 CIFSMaxBufSize +
1036 MAX_CIFS_HDR_SIZE, 0,
Paul Mundt20c2df82007-07-20 10:11:58 +09001037 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 if (cifs_req_cachep == NULL)
1039 return -ENOMEM;
1040
Steve French4523cc32007-04-30 20:13:06 +00001041 if (cifs_min_rcv < 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 cifs_min_rcv = 1;
1043 else if (cifs_min_rcv > 64) {
1044 cifs_min_rcv = 64;
Joe Perchesb6b38f72010-04-21 03:50:45 +00001045 cERROR(1, "cifs_min_rcv set to maximum (64)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 }
1047
Matthew Dobson93d23412006-03-26 01:37:50 -08001048 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1049 cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050
Steve French4523cc32007-04-30 20:13:06 +00001051 if (cifs_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 kmem_cache_destroy(cifs_req_cachep);
1053 return -ENOMEM;
1054 }
Steve Frenchec637e32005-12-12 20:53:18 -08001055 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 almost all handle based requests (but not write response, nor is it
1057 sufficient for path based requests). A smaller size would have
Steve French50c2f752007-07-13 00:33:32 +00001058 been more efficient (compacting multiple slab items on one 4k page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 for the case in which debug was on, but this larger size allows
1060 more SMBs to use small buffer alloc and is still much more
Steve French6dc0f872007-07-06 23:13:06 +00001061 efficient to alloc 1 per page off the slab compared to 17K (5page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 alloc of large cifs buffers even when page debugging is on */
1063 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
Steve French6dc0f872007-07-06 23:13:06 +00001064 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +09001065 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 if (cifs_sm_req_cachep == NULL) {
1067 mempool_destroy(cifs_req_poolp);
1068 kmem_cache_destroy(cifs_req_cachep);
Steve French6dc0f872007-07-06 23:13:06 +00001069 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 }
1071
Steve French4523cc32007-04-30 20:13:06 +00001072 if (cifs_min_small < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 cifs_min_small = 2;
1074 else if (cifs_min_small > 256) {
1075 cifs_min_small = 256;
Joe Perchesb6b38f72010-04-21 03:50:45 +00001076 cFYI(1, "cifs_min_small set to maximum (256)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 }
1078
Matthew Dobson93d23412006-03-26 01:37:50 -08001079 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1080 cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081
Steve French4523cc32007-04-30 20:13:06 +00001082 if (cifs_sm_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 mempool_destroy(cifs_req_poolp);
1084 kmem_cache_destroy(cifs_req_cachep);
1085 kmem_cache_destroy(cifs_sm_req_cachep);
1086 return -ENOMEM;
1087 }
1088
1089 return 0;
1090}
1091
1092static void
1093cifs_destroy_request_bufs(void)
1094{
1095 mempool_destroy(cifs_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001096 kmem_cache_destroy(cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 mempool_destroy(cifs_sm_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001098 kmem_cache_destroy(cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099}
1100
1101static int
1102cifs_init_mids(void)
1103{
1104 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
Steve French26f57362007-08-30 22:09:15 +00001105 sizeof(struct mid_q_entry), 0,
1106 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 if (cifs_mid_cachep == NULL)
1108 return -ENOMEM;
1109
Matthew Dobson93d23412006-03-26 01:37:50 -08001110 /* 3 is a reasonable minimum number of simultaneous operations */
1111 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
Steve French4523cc32007-04-30 20:13:06 +00001112 if (cifs_mid_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 kmem_cache_destroy(cifs_mid_cachep);
1114 return -ENOMEM;
1115 }
1116
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 return 0;
1118}
1119
1120static void
1121cifs_destroy_mids(void)
1122{
1123 mempool_destroy(cifs_mid_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001124 kmem_cache_destroy(cifs_mid_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125}
1126
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127static int __init
1128init_cifs(void)
1129{
1130 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 cifs_proc_init();
Jeff Laytone7ddee92008-11-14 13:44:38 -05001132 INIT_LIST_HEAD(&cifs_tcp_ses_list);
Steve French0eff0e22011-02-24 05:39:23 +00001133#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
Steve French4ca9c192005-10-10 19:52:13 -07001134 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1135 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
Steve French0eff0e22011-02-24 05:39:23 +00001136#endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137/*
1138 * Initialize Global counters
1139 */
1140 atomic_set(&sesInfoAllocCount, 0);
1141 atomic_set(&tconInfoAllocCount, 0);
Steve French6dc0f872007-07-06 23:13:06 +00001142 atomic_set(&tcpSesAllocCount, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 atomic_set(&tcpSesReconnectCount, 0);
1144 atomic_set(&tconInfoReconnectCount, 0);
1145
1146 atomic_set(&bufAllocCount, 0);
Steve French4498eed52005-12-03 13:58:57 -08001147 atomic_set(&smBufAllocCount, 0);
1148#ifdef CONFIG_CIFS_STATS2
1149 atomic_set(&totBufAllocCount, 0);
1150 atomic_set(&totSmBufAllocCount, 0);
1151#endif /* CONFIG_CIFS_STATS2 */
1152
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 atomic_set(&midCount, 0);
1154 GlobalCurrentXid = 0;
1155 GlobalTotalActiveXid = 0;
1156 GlobalMaxActiveXid = 0;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301157 spin_lock_init(&cifs_tcp_ses_lock);
Jeff Layton44772882010-10-15 15:34:03 -04001158 spin_lock_init(&cifs_file_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 spin_lock_init(&GlobalMid_Lock);
1160
Steve French4523cc32007-04-30 20:13:06 +00001161 if (cifs_max_pending < 2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 cifs_max_pending = 2;
Joe Perchesb6b38f72010-04-21 03:50:45 +00001163 cFYI(1, "cifs_max_pending set to min of 2");
Steve French4523cc32007-04-30 20:13:06 +00001164 } else if (cifs_max_pending > 256) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 cifs_max_pending = 256;
Joe Perchesb6b38f72010-04-21 03:50:45 +00001166 cFYI(1, "cifs_max_pending set to max of 256");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 }
1168
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301169 rc = cifs_fscache_register();
1170 if (rc)
Steve Frenchd3bf5222010-09-22 19:15:36 +00001171 goto out_clean_proc;
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301172
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 rc = cifs_init_inodecache();
Steve French45af7a02006-04-21 22:52:25 +00001174 if (rc)
Steve Frenchd3bf5222010-09-22 19:15:36 +00001175 goto out_unreg_fscache;
Steve French45af7a02006-04-21 22:52:25 +00001176
1177 rc = cifs_init_mids();
1178 if (rc)
1179 goto out_destroy_inodecache;
1180
1181 rc = cifs_init_request_bufs();
1182 if (rc)
1183 goto out_destroy_mids;
1184
Jeff Layton84a15b92007-11-03 05:02:24 +00001185#ifdef CONFIG_CIFS_UPCALL
1186 rc = register_key_type(&cifs_spnego_key_type);
1187 if (rc)
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001188 goto out_destroy_request_bufs;
1189#endif /* CONFIG_CIFS_UPCALL */
1190
1191#ifdef CONFIG_CIFS_ACL
1192 rc = init_cifs_idmap();
1193 if (rc)
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001194 goto out_register_key_type;
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001195#endif /* CONFIG_CIFS_ACL */
1196
1197 rc = register_filesystem(&cifs_fs_type);
1198 if (rc)
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001199 goto out_init_cifs_idmap;
Steve French45af7a02006-04-21 22:52:25 +00001200
Steve French45af7a02006-04-21 22:52:25 +00001201 return 0;
1202
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001203out_init_cifs_idmap:
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001204#ifdef CONFIG_CIFS_ACL
1205 exit_cifs_idmap();
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001206out_register_key_type:
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001207#endif
1208#ifdef CONFIG_CIFS_UPCALL
1209 unregister_key_type(&cifs_spnego_key_type);
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001210out_destroy_request_bufs:
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001211#endif
Steve French45af7a02006-04-21 22:52:25 +00001212 cifs_destroy_request_bufs();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001213out_destroy_mids:
Steve French45af7a02006-04-21 22:52:25 +00001214 cifs_destroy_mids();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001215out_destroy_inodecache:
Steve French45af7a02006-04-21 22:52:25 +00001216 cifs_destroy_inodecache();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001217out_unreg_fscache:
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301218 cifs_fscache_unregister();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001219out_clean_proc:
1220 cifs_proc_clean();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 return rc;
1222}
1223
1224static void __exit
1225exit_cifs(void)
1226{
Joe Perchesb6b38f72010-04-21 03:50:45 +00001227 cFYI(DBG2, "exit_cifs");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 cifs_proc_clean();
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301229 cifs_fscache_unregister();
Steve French61033352008-01-09 16:21:36 +00001230#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov78d31a32008-04-24 12:56:07 +04001231 cifs_dfs_release_automount_timer();
Steve French61033352008-01-09 16:21:36 +00001232#endif
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001233#ifdef CONFIG_CIFS_ACL
1234 cifs_destroy_idmaptrees();
1235 exit_cifs_idmap();
1236#endif
Jeff Layton84a15b92007-11-03 05:02:24 +00001237#ifdef CONFIG_CIFS_UPCALL
1238 unregister_key_type(&cifs_spnego_key_type);
1239#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 unregister_filesystem(&cifs_fs_type);
1241 cifs_destroy_inodecache();
1242 cifs_destroy_mids();
1243 cifs_destroy_request_bufs();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244}
1245
1246MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
Steve French6dc0f872007-07-06 23:13:06 +00001247MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248MODULE_DESCRIPTION
Steve French63135e02007-07-17 17:34:02 +00001249 ("VFS to access servers complying with the SNIA CIFS Specification "
1250 "e.g. Samba and Windows");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251MODULE_VERSION(CIFS_VERSION);
1252module_init(init_cifs)
1253module_exit(exit_cifs)