blob: bc4b12ca537bfaf1a6556cf0b1df5a4bc8af25ac [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;
56unsigned int oplockEnabled = 1;
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;
77module_param(cifs_max_pending, int, 0);
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.");
Linus Torvalds1da177e2005-04-16 15:20:36 -070085extern mempool_t *cifs_sm_req_poolp;
86extern mempool_t *cifs_req_poolp;
87extern mempool_t *cifs_mid_poolp;
88
Jeff Laytond7c86ff2010-10-11 15:07:19 -040089void
90cifs_sb_active(struct super_block *sb)
91{
92 struct cifs_sb_info *server = CIFS_SB(sb);
93
94 if (atomic_inc_return(&server->active) == 1)
95 atomic_inc(&sb->s_active);
96}
97
98void
99cifs_sb_deactive(struct super_block *sb)
100{
101 struct cifs_sb_info *server = CIFS_SB(sb);
102
103 if (atomic_dec_and_test(&server->active))
104 deactivate_super(sb);
105}
106
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107static int
Al Viro97d11522011-06-17 09:29:57 -0400108cifs_read_super(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109{
110 struct inode *inode;
Pavel Shilovskyb2e5cd32011-05-25 13:35:34 +0400111 struct cifs_sb_info *cifs_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +0000113
Pavel Shilovskyb2e5cd32011-05-25 13:35:34 +0400114 cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115
Al Viro2c6292a2011-06-17 09:05:48 -0400116 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
117 sb->s_flags |= MS_POSIXACL;
118
119 if (cifs_sb_master_tcon(cifs_sb)->ses->capabilities & CAP_LARGE_FILES)
120 sb->s_maxbytes = MAX_LFS_FILESIZE;
121 else
122 sb->s_maxbytes = MAX_NON_LFS;
123
124 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
125 sb->s_time_gran = 100;
126
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 sb->s_magic = CIFS_MAGIC_NUMBER;
128 sb->s_op = &cifs_super_ops;
Jens Axboe8044f7f2010-04-22 12:09:48 +0200129 sb->s_bdi = &cifs_sb->bdi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 sb->s_blocksize = CIFS_MAX_MSGSIZE;
131 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
Shirish Pargaonkar9b6763e2011-02-21 23:56:59 -0600132 inode = cifs_root_iget(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
David Howellsce634ab2008-02-07 00:15:33 -0800134 if (IS_ERR(inode)) {
135 rc = PTR_ERR(inode);
136 inode = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 goto out_no_root;
138 }
139
140 sb->s_root = d_alloc_root(inode);
141
142 if (!sb->s_root) {
143 rc = -ENOMEM;
144 goto out_no_root;
145 }
Steve French50c2f752007-07-13 00:33:32 +0000146
Al Viro1c929cf2010-12-18 11:43:51 -0500147 /* do that *after* d_alloc_root() - we want NULL ->d_op for root here */
148 if (cifs_sb_master_tcon(cifs_sb)->nocase)
149 sb->s_d_op = &cifs_ci_dentry_ops;
150 else
151 sb->s_d_op = &cifs_dentry_ops;
152
Shirish Pargaonkar25720872011-02-25 10:48:55 -0600153#ifdef CIFS_NFSD_EXPORT
Steve French7521a3c2007-07-11 18:30:34 +0000154 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000155 cFYI(1, "export ops supported");
Steve French7521a3c2007-07-11 18:30:34 +0000156 sb->s_export_op = &cifs_export_ops;
157 }
Shirish Pargaonkar25720872011-02-25 10:48:55 -0600158#endif /* CIFS_NFSD_EXPORT */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
160 return 0;
161
162out_no_root:
Joe Perchesb6b38f72010-04-21 03:50:45 +0000163 cERROR(1, "cifs_read_super: get root inode failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 if (inode)
165 iput(inode);
Steve French54b46022008-08-11 22:31:40 +0000166
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 return rc;
168}
169
Al Viro6d686172011-06-17 08:34:57 -0400170static void cifs_kill_sb(struct super_block *sb)
171{
172 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
173 kill_anon_super(sb);
Al Viro98ab4942011-06-17 09:32:10 -0400174 cifs_umount(cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175}
176
177static int
David Howells726c3342006-06-23 02:02:58 -0700178cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179{
David Howells726c3342006-06-23 02:02:58 -0700180 struct super_block *sb = dentry->d_sb;
Steve French39da9842008-04-28 04:04:34 +0000181 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French96daf2b2011-05-27 04:34:02 +0000182 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Steve Frenchc81156d2005-04-28 22:41:07 -0700183 int rc = -EOPNOTSUPP;
Steve French39da9842008-04-28 04:04:34 +0000184 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185
186 xid = GetXid();
187
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 buf->f_type = CIFS_MAGIC_NUMBER;
189
Steve French39da9842008-04-28 04:04:34 +0000190 /*
191 * PATH_MAX may be too long - it would presumably be total path,
192 * but note that some servers (includinng Samba 3) have a shorter
193 * maximum path.
194 *
195 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
196 */
197 buf->f_namelen = PATH_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 buf->f_files = 0; /* undefined */
199 buf->f_ffree = 0; /* unlimited */
200
Steve French39da9842008-04-28 04:04:34 +0000201 /*
202 * We could add a second check for a QFS Unix capability bit
203 */
204 if ((tcon->ses->capabilities & CAP_UNIX) &&
205 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
206 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
Steve French39da9842008-04-28 04:04:34 +0000208 /*
209 * Only need to call the old QFSInfo if failed on newer one,
210 * e.g. by OS/2.
211 **/
212 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
213 rc = CIFSSMBQFSInfo(xid, tcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
Steve French39da9842008-04-28 04:04:34 +0000215 /*
216 * Some old Windows servers also do not support level 103, retry with
217 * older level one if old server failed the previous call or we
218 * bypassed it because we detected that this was an older LANMAN sess
219 */
Steve French4523cc32007-04-30 20:13:06 +0000220 if (rc)
Steve French39da9842008-04-28 04:04:34 +0000221 rc = SMBOldQFSInfo(xid, tcon, buf);
222
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 FreeXid(xid);
Steve French39da9842008-04-28 04:04:34 +0000224 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225}
226
Nick Pigginb74c79e2011-01-07 17:49:58 +1100227static int cifs_permission(struct inode *inode, int mask, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228{
229 struct cifs_sb_info *cifs_sb;
230
231 cifs_sb = CIFS_SB(inode->i_sb);
232
Miklos Szeredif696a362008-07-31 13:41:58 +0200233 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
234 if ((mask & MAY_EXEC) && !execute_ok(inode))
235 return -EACCES;
236 else
237 return 0;
238 } else /* file mode might have been restricted at mount time
Steve French50c2f752007-07-13 00:33:32 +0000239 on the client (above and beyond ACL on servers) for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 servers which do not support setting and viewing mode bits,
Steve French50c2f752007-07-13 00:33:32 +0000241 so allowing client to check permissions is useful */
Nick Pigginb74c79e2011-01-07 17:49:58 +1100242 return generic_permission(inode, mask, flags, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243}
244
Christoph Lametere18b8902006-12-06 20:33:20 -0800245static struct kmem_cache *cifs_inode_cachep;
246static struct kmem_cache *cifs_req_cachep;
247static struct kmem_cache *cifs_mid_cachep;
Christoph Lametere18b8902006-12-06 20:33:20 -0800248static struct kmem_cache *cifs_sm_req_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249mempool_t *cifs_sm_req_poolp;
250mempool_t *cifs_req_poolp;
251mempool_t *cifs_mid_poolp;
252
253static struct inode *
254cifs_alloc_inode(struct super_block *sb)
255{
256 struct cifsInodeInfo *cifs_inode;
Christoph Lametere94b1762006-12-06 20:33:17 -0800257 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 if (!cifs_inode)
259 return NULL;
260 cifs_inode->cifsAttrs = 0x20; /* default */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 cifs_inode->time = 0;
262 /* Until the file is open and we have gotten oplock
263 info back from the server, can not assume caching of
264 file data or metadata */
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300265 cifs_set_oplock_level(cifs_inode, 0);
Jeff Layton9a8165f2008-10-17 21:03:20 -0400266 cifs_inode->delete_pending = false;
Jeff Laytondf2cf172010-02-12 07:44:16 -0500267 cifs_inode->invalid_mapping = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400269 cifs_inode->server_eof = 0;
Jeff Layton20054bd2011-01-07 11:30:27 -0500270 cifs_inode->uniqueid = 0;
271 cifs_inode->createtime = 0;
Steve French50c2f752007-07-13 00:33:32 +0000272
Steve French1b2b2122007-02-17 04:30:54 +0000273 /* Can not set i_flags here - they get immediately overwritten
274 to zero by the VFS */
275/* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 INIT_LIST_HEAD(&cifs_inode->openFileList);
277 return &cifs_inode->vfs_inode;
278}
279
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100280static void cifs_i_callback(struct rcu_head *head)
281{
282 struct inode *inode = container_of(head, struct inode, i_rcu);
283 INIT_LIST_HEAD(&inode->i_dentry);
284 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
285}
286
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287static void
288cifs_destroy_inode(struct inode *inode)
289{
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100290 call_rcu(&inode->i_rcu, cifs_i_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291}
292
Jeff Layton61f98ff2009-06-11 10:27:32 -0400293static void
Al Virob57922d2010-06-07 14:34:48 -0400294cifs_evict_inode(struct inode *inode)
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530295{
Al Virob57922d2010-06-07 14:34:48 -0400296 truncate_inode_pages(&inode->i_data, 0);
297 end_writeback(inode);
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530298 cifs_fscache_release_inode_cookie(inode);
299}
300
301static void
Jeff Layton61f98ff2009-06-11 10:27:32 -0400302cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
303{
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300304 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
305 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
306
Jeff Layton61f98ff2009-06-11 10:27:32 -0400307 seq_printf(s, ",addr=");
308
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300309 switch (server->dstaddr.ss_family) {
Jeff Layton61f98ff2009-06-11 10:27:32 -0400310 case AF_INET:
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300311 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
Jeff Layton61f98ff2009-06-11 10:27:32 -0400312 break;
313 case AF_INET6:
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300314 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
315 if (sa6->sin6_scope_id)
316 seq_printf(s, "%%%u", sa6->sin6_scope_id);
Jeff Layton61f98ff2009-06-11 10:27:32 -0400317 break;
318 default:
319 seq_printf(s, "(unknown)");
320 }
321}
322
Jeff Layton3e715512011-06-13 11:50:41 -0400323static void
324cifs_show_security(struct seq_file *s, struct TCP_Server_Info *server)
325{
326 seq_printf(s, ",sec=");
327
328 switch (server->secType) {
329 case LANMAN:
330 seq_printf(s, "lanman");
331 break;
332 case NTLMv2:
333 seq_printf(s, "ntlmv2");
334 break;
335 case NTLM:
336 seq_printf(s, "ntlm");
337 break;
338 case Kerberos:
339 seq_printf(s, "krb5");
340 break;
341 case RawNTLMSSP:
342 seq_printf(s, "ntlmssp");
343 break;
344 default:
345 /* shouldn't ever happen */
346 seq_printf(s, "unknown");
347 break;
348 }
349
350 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
351 seq_printf(s, "i");
352}
353
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354/*
355 * cifs_show_options() is for displaying mount options in /proc/mounts.
356 * Not all settable options are displayed but most of the important
357 * ones are.
358 */
359static int
360cifs_show_options(struct seq_file *s, struct vfsmount *m)
361{
Jeff Layton8e047d02009-08-28 10:11:10 -0400362 struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
Steve French96daf2b2011-05-27 04:34:02 +0000363 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Ben Greear3eb9a882010-09-01 17:06:02 -0700364 struct sockaddr *srcaddr;
365 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
Jeff Layton3e715512011-06-13 11:50:41 -0400367 cifs_show_security(s, tcon->ses->server);
368
Jeff Layton8e047d02009-08-28 10:11:10 -0400369 seq_printf(s, ",unc=%s", tcon->treeName);
Jeff Layton29e07c82010-09-29 19:51:12 -0400370
371 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
372 seq_printf(s, ",multiuser");
Steve French8727c8a2011-02-25 01:11:56 -0600373 else if (tcon->ses->user_name)
374 seq_printf(s, ",username=%s", tcon->ses->user_name);
Jeff Layton29e07c82010-09-29 19:51:12 -0400375
Jeff Layton8616e0f2009-06-11 10:27:28 -0400376 if (tcon->ses->domainName)
377 seq_printf(s, ",domain=%s", tcon->ses->domainName);
378
Ben Greear3eb9a882010-09-01 17:06:02 -0700379 if (srcaddr->sa_family != AF_UNSPEC) {
380 struct sockaddr_in *saddr4;
381 struct sockaddr_in6 *saddr6;
382 saddr4 = (struct sockaddr_in *)srcaddr;
383 saddr6 = (struct sockaddr_in6 *)srcaddr;
384 if (srcaddr->sa_family == AF_INET6)
385 seq_printf(s, ",srcaddr=%pI6c",
386 &saddr6->sin6_addr);
387 else if (srcaddr->sa_family == AF_INET)
388 seq_printf(s, ",srcaddr=%pI4",
389 &saddr4->sin_addr.s_addr);
390 else
391 seq_printf(s, ",srcaddr=BAD-AF:%i",
392 (int)(srcaddr->sa_family));
393 }
394
Jeff Layton8616e0f2009-06-11 10:27:28 -0400395 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
Jeff Layton340481a32009-06-11 10:27:29 -0400396 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
397 seq_printf(s, ",forceuid");
Jeff Layton4486d6e2009-08-03 12:45:10 -0400398 else
399 seq_printf(s, ",noforceuid");
Jeff Layton340481a32009-06-11 10:27:29 -0400400
Jeff Layton8616e0f2009-06-11 10:27:28 -0400401 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
Jeff Layton340481a32009-06-11 10:27:29 -0400402 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
403 seq_printf(s, ",forcegid");
Jeff Layton4486d6e2009-08-03 12:45:10 -0400404 else
405 seq_printf(s, ",noforcegid");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400406
Jeff Layton61f98ff2009-06-11 10:27:32 -0400407 cifs_show_address(s, tcon->ses->server);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400408
409 if (!tcon->unix_ext)
410 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
Steve French2b280fa2008-05-17 03:12:45 +0000411 cifs_sb->mnt_file_mode,
412 cifs_sb->mnt_dir_mode);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400413 if (tcon->seal)
414 seq_printf(s, ",seal");
415 if (tcon->nocase)
416 seq_printf(s, ",nocase");
417 if (tcon->retry)
418 seq_printf(s, ",hard");
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000419 if (tcon->unix_ext)
420 seq_printf(s, ",unix");
421 else
422 seq_printf(s, ",nounix");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400423 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
424 seq_printf(s, ",posixpaths");
425 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
426 seq_printf(s, ",setuids");
427 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
428 seq_printf(s, ",serverino");
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000429 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
430 seq_printf(s, ",rwpidforward");
431 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
432 seq_printf(s, ",forcemand");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400433 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
434 seq_printf(s, ",directio");
435 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
436 seq_printf(s, ",nouser_xattr");
437 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
438 seq_printf(s, ",mapchars");
439 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
440 seq_printf(s, ",sfu");
441 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
442 seq_printf(s, ",nobrl");
443 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
444 seq_printf(s, ",cifsacl");
445 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
446 seq_printf(s, ",dynperm");
447 if (m->mnt_sb->s_flags & MS_POSIXACL)
448 seq_printf(s, ",acl");
Stefan Metzmacher736a3322010-07-30 14:56:00 +0200449 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
450 seq_printf(s, ",mfsymlinks");
Suresh Jayaraman476428f2010-11-24 17:49:07 +0530451 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
452 seq_printf(s, ",fsc");
Steve French2b280fa2008-05-17 03:12:45 +0000453
Jeff Layton8616e0f2009-06-11 10:27:28 -0400454 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
455 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
Suresh Jayaraman6d20e842010-12-01 14:42:28 +0530456 /* convert actimeo and display it in seconds */
457 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400458
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 return 0;
460}
461
Al Viro42faad92008-04-24 07:21:56 -0400462static void cifs_umount_begin(struct super_block *sb)
Steve French68058e72005-10-10 10:34:22 -0700463{
Al Viro42faad92008-04-24 07:21:56 -0400464 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French96daf2b2011-05-27 04:34:02 +0000465 struct cifs_tcon *tcon;
Steve French68058e72005-10-10 10:34:22 -0700466
Steve French4523cc32007-04-30 20:13:06 +0000467 if (cifs_sb == NULL)
Steve French9e2e85f2005-10-10 14:28:38 -0700468 return;
469
Jeff Layton0d424ad2010-09-20 16:01:35 -0700470 tcon = cifs_sb_master_tcon(cifs_sb);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500471
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530472 spin_lock(&cifs_tcp_ses_lock);
Steve Frenchad8034f2009-06-26 03:25:49 +0000473 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
474 /* we have other mounts to same share or we have
475 already tried to force umount this and woken up
476 all waiting network requests, nothing to do */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530477 spin_unlock(&cifs_tcp_ses_lock);
Steve Frenchad8034f2009-06-26 03:25:49 +0000478 return;
479 } else if (tcon->tc_count == 1)
Steve French5e1253b2005-10-10 14:06:37 -0700480 tcon->tidStatus = CifsExiting;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530481 spin_unlock(&cifs_tcp_ses_lock);
Steve French5e1253b2005-10-10 14:06:37 -0700482
Steve French3a5ff612006-07-14 22:37:11 +0000483 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
Steve French7b7abfe2005-11-09 15:21:09 -0800484 /* cancel_notify_requests(tcon); */
Steve French50c2f752007-07-13 00:33:32 +0000485 if (tcon->ses && tcon->ses->server) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000486 cFYI(1, "wake up tasks now - umount begin not complete");
Steve French9e2e85f2005-10-10 14:28:38 -0700487 wake_up_all(&tcon->ses->server->request_q);
Steve French6ab16d22005-11-29 20:55:11 -0800488 wake_up_all(&tcon->ses->server->response_q);
489 msleep(1); /* yield */
490 /* we have to kick the requests once more */
491 wake_up_all(&tcon->ses->server->response_q);
492 msleep(1);
Steve French5e1253b2005-10-10 14:06:37 -0700493 }
Steve French68058e72005-10-10 10:34:22 -0700494
495 return;
496}
Steve French68058e72005-10-10 10:34:22 -0700497
Steve Frenchbf97d282006-09-28 21:34:06 +0000498#ifdef CONFIG_CIFS_STATS2
499static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
500{
501 /* BB FIXME */
502 return 0;
503}
504#endif
505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506static int cifs_remount(struct super_block *sb, int *flags, char *data)
507{
508 *flags |= MS_NODIRATIME;
509 return 0;
510}
511
Al Viro45321ac2010-06-07 13:43:19 -0400512static int cifs_drop_inode(struct inode *inode)
Jeff Layton12420ac2010-06-01 14:47:40 -0400513{
514 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
515
Al Viro45321ac2010-06-07 13:43:19 -0400516 /* no serverino => unconditional eviction */
517 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
518 generic_drop_inode(inode);
Jeff Layton12420ac2010-06-01 14:47:40 -0400519}
520
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800521static const struct super_operations cifs_super_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 .statfs = cifs_statfs,
523 .alloc_inode = cifs_alloc_inode,
524 .destroy_inode = cifs_destroy_inode,
Jeff Layton12420ac2010-06-01 14:47:40 -0400525 .drop_inode = cifs_drop_inode,
Al Virob57922d2010-06-07 14:34:48 -0400526 .evict_inode = cifs_evict_inode,
Jeff Layton12420ac2010-06-01 14:47:40 -0400527/* .delete_inode = cifs_delete_inode, */ /* Do not need above
528 function unless later we add lazy close of inodes or unless the
Steve French50c2f752007-07-13 00:33:32 +0000529 kernel forgets to call us with the same number of releases (closes)
530 as opens */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 .show_options = cifs_show_options,
Steve French7b7abfe2005-11-09 15:21:09 -0800532 .umount_begin = cifs_umount_begin,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 .remount_fs = cifs_remount,
Steve Frenchbf97d282006-09-28 21:34:06 +0000534#ifdef CONFIG_CIFS_STATS2
Steve Frenchf46d3e12006-09-30 01:08:55 +0000535 .show_stats = cifs_show_stats,
Steve Frenchbf97d282006-09-28 21:34:06 +0000536#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537};
538
Steve Frenchf87d39d2011-05-27 03:50:55 +0000539/*
540 * Get root dentry from superblock according to prefix path mount option.
541 * Return dentry with refcount + 1 on success and NULL otherwise.
542 */
543static struct dentry *
544cifs_get_root(struct smb_vol *vol, struct super_block *sb)
545{
Al Virofec11dd2011-07-18 13:50:40 -0400546 struct dentry *dentry;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000547 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Al Virofec11dd2011-07-18 13:50:40 -0400548 char *full_path = NULL;
549 char *s, *p;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000550 char sep;
Al Virofec11dd2011-07-18 13:50:40 -0400551 int xid;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000552
553 full_path = cifs_build_path_to_root(vol, cifs_sb,
554 cifs_sb_master_tcon(cifs_sb));
555 if (full_path == NULL)
Al Viro9403c9c2011-06-17 10:02:59 -0400556 return ERR_PTR(-ENOMEM);
Steve Frenchf87d39d2011-05-27 03:50:55 +0000557
558 cFYI(1, "Get root dentry for %s", full_path);
559
560 xid = GetXid();
561 sep = CIFS_DIR_SEP(cifs_sb);
Al Virofec11dd2011-07-18 13:50:40 -0400562 dentry = dget(sb->s_root);
563 p = s = full_path;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000564
Al Virofec11dd2011-07-18 13:50:40 -0400565 do {
566 struct inode *dir = dentry->d_inode;
567 struct dentry *child;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000568
Al Virofec11dd2011-07-18 13:50:40 -0400569 /* skip separators */
570 while (*s == sep)
571 s++;
572 if (!*s)
573 break;
574 p = s++;
575 /* next separator */
576 while (*s && *s != sep)
577 s++;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000578
Al Virofec11dd2011-07-18 13:50:40 -0400579 mutex_lock(&dir->i_mutex);
580 child = lookup_one_len(p, dentry, s - p);
581 mutex_unlock(&dir->i_mutex);
582 dput(dentry);
583 dentry = child;
584 } while (!IS_ERR(dentry));
Steve Frenchf87d39d2011-05-27 03:50:55 +0000585 _FreeXid(xid);
586 kfree(full_path);
Al Virofec11dd2011-07-18 13:50:40 -0400587 return dentry;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000588}
589
Al Viroee01a142011-06-17 09:47:23 -0400590static int cifs_set_super(struct super_block *sb, void *data)
591{
592 struct cifs_mnt_data *mnt_data = data;
593 sb->s_fs_info = mnt_data->cifs_sb;
594 return set_anon_super(sb, NULL);
595}
596
Al Virod753ed92010-07-26 12:52:33 +0400597static struct dentry *
598cifs_do_mount(struct file_system_type *fs_type,
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000599 int flags, const char *dev_name, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600{
601 int rc;
Jan Blunckdb719222010-08-15 22:51:10 +0200602 struct super_block *sb;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000603 struct cifs_sb_info *cifs_sb;
604 struct smb_vol *volume_info;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400605 struct cifs_mnt_data mnt_data;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000606 struct dentry *root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
Joe Perchesb6b38f72010-04-21 03:50:45 +0000608 cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
Jeff Layton04db79b2011-07-06 08:10:38 -0400610 volume_info = cifs_get_volume_info((char *)data, dev_name);
611 if (IS_ERR(volume_info))
612 return ERR_CAST(volume_info);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000613
614 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
615 if (cifs_sb == NULL) {
616 root = ERR_PTR(-ENOMEM);
Al Viro5c4f1ad2011-06-17 09:56:55 -0400617 goto out_nls;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000618 }
619
Al Viro5d3bc602011-06-17 09:17:28 -0400620 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
621 if (cifs_sb->mountdata == NULL) {
622 root = ERR_PTR(-ENOMEM);
Al Viro5c4f1ad2011-06-17 09:56:55 -0400623 goto out_cifs_sb;
Al Viro5d3bc602011-06-17 09:17:28 -0400624 }
625
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000626 cifs_setup_cifs_sb(volume_info, cifs_sb);
627
Al Viro97d11522011-06-17 09:29:57 -0400628 rc = cifs_mount(cifs_sb, volume_info);
629 if (rc) {
630 if (!(flags & MS_SILENT))
631 cERROR(1, "cifs_mount failed w/return code = %d", rc);
632 root = ERR_PTR(rc);
Al Viro5c4f1ad2011-06-17 09:56:55 -0400633 goto out_mountdata;
Al Viro97d11522011-06-17 09:29:57 -0400634 }
635
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400636 mnt_data.vol = volume_info;
637 mnt_data.cifs_sb = cifs_sb;
638 mnt_data.flags = flags;
639
Al Viroee01a142011-06-17 09:47:23 -0400640 sb = sget(fs_type, cifs_match_super, cifs_set_super, &mnt_data);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000641 if (IS_ERR(sb)) {
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000642 root = ERR_CAST(sb);
Al Viro97d11522011-06-17 09:29:57 -0400643 cifs_umount(cifs_sb);
Al Virod757d712011-06-17 09:42:43 -0400644 goto out;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000645 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
Al Viroee01a142011-06-17 09:47:23 -0400647 if (sb->s_root) {
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400648 cFYI(1, "Use existing superblock");
Al Viro97d11522011-06-17 09:29:57 -0400649 cifs_umount(cifs_sb);
Al Viro5c4f1ad2011-06-17 09:56:55 -0400650 } else {
651 sb->s_flags = flags;
652 /* BB should we make this contingent on mount parm? */
653 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
654
655 rc = cifs_read_super(sb);
656 if (rc) {
657 root = ERR_PTR(rc);
658 goto out_super;
659 }
660
661 sb->s_flags |= MS_ACTIVE;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400662 }
663
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400664 root = cifs_get_root(volume_info, sb);
Al Viro9403c9c2011-06-17 10:02:59 -0400665 if (IS_ERR(root))
Al Virofa18f1b2011-06-17 09:50:44 -0400666 goto out_super;
Al Virofa18f1b2011-06-17 09:50:44 -0400667
668 cFYI(1, "dentry root is: %p", root);
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400669 goto out;
670
Pavel Shilovsky641a58d2011-05-26 00:02:16 +0400671out_super:
Pavel Shilovsky641a58d2011-05-26 00:02:16 +0400672 deactivate_locked_super(sb);
Pavel Shilovsky641a58d2011-05-26 00:02:16 +0400673out:
Jeff Laytonf9e59bc2011-07-06 08:10:37 -0400674 cifs_cleanup_volume_info(volume_info);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000675 return root;
Al Viro5c4f1ad2011-06-17 09:56:55 -0400676
677out_mountdata:
678 kfree(cifs_sb->mountdata);
679out_cifs_sb:
680 kfree(cifs_sb);
681out_nls:
682 unload_nls(volume_info->local_nls);
683 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684}
685
Badari Pulavarty027445c2006-09-30 23:28:46 -0700686static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
687 unsigned long nr_segs, loff_t pos)
Steve French87c89dd2005-11-17 17:03:00 -0800688{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800689 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
Steve French87c89dd2005-11-17 17:03:00 -0800690 ssize_t written;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500691 int rc;
Steve French87c89dd2005-11-17 17:03:00 -0800692
Badari Pulavarty027445c2006-09-30 23:28:46 -0700693 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500694
695 if (CIFS_I(inode)->clientCanCacheAll)
696 return written;
697
698 rc = filemap_fdatawrite(inode->i_mapping);
699 if (rc)
700 cFYI(1, "cifs_file_aio_write: %d rc on %p inode", rc, inode);
701
Steve French87c89dd2005-11-17 17:03:00 -0800702 return written;
703}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704
Steve Frenchc32a0b62006-01-12 14:41:28 -0800705static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
706{
707 /* origin == SEEK_END => we must revalidate the cached file length */
Steve French0889a942006-09-23 22:11:07 +0000708 if (origin == SEEK_END) {
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400709 int rc;
710 struct inode *inode = file->f_path.dentry->d_inode;
Steve French030e9d82007-02-01 04:27:59 +0000711
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400712 /*
713 * We need to be sure that all dirty pages are written and the
714 * server has the newest file length.
715 */
716 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
717 inode->i_mapping->nrpages != 0) {
718 rc = filemap_fdatawait(inode->i_mapping);
Steve French156ecb22011-05-20 17:00:01 +0000719 if (rc) {
720 mapping_set_error(inode->i_mapping, rc);
721 return rc;
722 }
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400723 }
724 /*
725 * Some applications poll for the file length in this strange
726 * way so we must seek to end on non-oplocked files by
727 * setting the revalidate time to zero.
728 */
729 CIFS_I(inode)->time = 0;
Steve French030e9d82007-02-01 04:27:59 +0000730
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400731 rc = cifs_revalidate_file_attr(file);
732 if (rc < 0)
733 return (loff_t)rc;
Steve Frenchc32a0b62006-01-12 14:41:28 -0800734 }
Andi Kleen9465efc2008-06-27 11:05:24 +0200735 return generic_file_llseek_unlocked(file, offset, origin);
Steve Frenchc32a0b62006-01-12 14:41:28 -0800736}
737
Steve French84210e92008-10-23 04:42:37 +0000738static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
739{
Arnd Bergmannb89f4322010-09-18 15:09:31 +0200740 /* note that this is called by vfs setlease with lock_flocks held
741 to protect *lease from going away */
Steve French84210e92008-10-23 04:42:37 +0000742 struct inode *inode = file->f_path.dentry->d_inode;
Jeff Laytonba00ba62010-09-20 16:01:31 -0700743 struct cifsFileInfo *cfile = file->private_data;
Steve French84210e92008-10-23 04:42:37 +0000744
745 if (!(S_ISREG(inode->i_mode)))
746 return -EINVAL;
747
748 /* check if file is oplocked */
749 if (((arg == F_RDLCK) &&
750 (CIFS_I(inode)->clientCanCacheRead)) ||
751 ((arg == F_WRLCK) &&
752 (CIFS_I(inode)->clientCanCacheAll)))
753 return generic_setlease(file, arg, lease);
Jeff Layton13cfb732010-09-29 19:51:11 -0400754 else if (tlink_tcon(cfile->tlink)->local_lease &&
755 !CIFS_I(inode)->clientCanCacheRead)
Steve French84210e92008-10-23 04:42:37 +0000756 /* If the server claims to support oplock on this
757 file, then we still need to check oplock even
758 if the local_lease mount option is set, but there
759 are servers which do not support oplock for which
760 this mount option may be useful if the user
761 knows that the file won't be changed on the server
762 by anyone else */
763 return generic_setlease(file, arg, lease);
Christoph Hellwig51ee4b82010-10-31 08:35:10 -0400764 else
Steve French84210e92008-10-23 04:42:37 +0000765 return -EAGAIN;
766}
Steve French84210e92008-10-23 04:42:37 +0000767
Igor Mammedove6ab1582008-01-11 01:49:48 +0000768struct file_system_type cifs_fs_type = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 .owner = THIS_MODULE,
770 .name = "cifs",
Al Virod753ed92010-07-26 12:52:33 +0400771 .mount = cifs_do_mount,
Al Viro6d686172011-06-17 08:34:57 -0400772 .kill_sb = cifs_kill_sb,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 /* .fs_flags */
774};
Arjan van de Ven754661f2007-02-12 00:55:38 -0800775const struct inode_operations cifs_dir_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 .create = cifs_create,
777 .lookup = cifs_lookup,
778 .getattr = cifs_getattr,
779 .unlink = cifs_unlink,
780 .link = cifs_hardlink,
781 .mkdir = cifs_mkdir,
782 .rmdir = cifs_rmdir,
783 .rename = cifs_rename,
784 .permission = cifs_permission,
785/* revalidate:cifs_revalidate, */
786 .setattr = cifs_setattr,
787 .symlink = cifs_symlink,
788 .mknod = cifs_mknod,
789#ifdef CONFIG_CIFS_XATTR
790 .setxattr = cifs_setxattr,
791 .getxattr = cifs_getxattr,
792 .listxattr = cifs_listxattr,
793 .removexattr = cifs_removexattr,
794#endif
795};
796
Arjan van de Ven754661f2007-02-12 00:55:38 -0800797const struct inode_operations cifs_file_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798/* revalidate:cifs_revalidate, */
799 .setattr = cifs_setattr,
800 .getattr = cifs_getattr, /* do we need this anymore? */
801 .rename = cifs_rename,
802 .permission = cifs_permission,
803#ifdef CONFIG_CIFS_XATTR
804 .setxattr = cifs_setxattr,
805 .getxattr = cifs_getxattr,
806 .listxattr = cifs_listxattr,
807 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000808#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809};
810
Arjan van de Ven754661f2007-02-12 00:55:38 -0800811const struct inode_operations cifs_symlink_inode_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000812 .readlink = generic_readlink,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 .follow_link = cifs_follow_link,
814 .put_link = cifs_put_link,
815 .permission = cifs_permission,
816 /* BB add the following two eventually */
817 /* revalidate: cifs_revalidate,
818 setattr: cifs_notify_change, *//* BB do we need notify change */
819#ifdef CONFIG_CIFS_XATTR
820 .setxattr = cifs_setxattr,
821 .getxattr = cifs_getxattr,
822 .listxattr = cifs_listxattr,
823 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000824#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825};
826
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800827const struct file_operations cifs_file_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800828 .read = do_sync_read,
829 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800830 .aio_read = generic_file_aio_read,
831 .aio_write = cifs_file_aio_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 .open = cifs_open,
833 .release = cifs_close,
834 .lock = cifs_lock,
835 .fsync = cifs_fsync,
836 .flush = cifs_flush,
837 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200838 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800839 .llseek = cifs_llseek,
Steve Frenchc67593a2005-04-28 22:41:04 -0700840#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000841 .unlocked_ioctl = cifs_ioctl,
Steve Frenchc67593a2005-04-28 22:41:04 -0700842#endif /* CONFIG_CIFS_POSIX */
Steve French84210e92008-10-23 04:42:37 +0000843 .setlease = cifs_setlease,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844};
845
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300846const struct file_operations cifs_file_strict_ops = {
847 .read = do_sync_read,
848 .write = do_sync_write,
Pavel Shilovskya70307e2010-12-14 11:50:41 +0300849 .aio_read = cifs_strict_readv,
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500850 .aio_write = cifs_strict_writev,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300851 .open = cifs_open,
852 .release = cifs_close,
853 .lock = cifs_lock,
854 .fsync = cifs_strict_fsync,
855 .flush = cifs_flush,
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +0300856 .mmap = cifs_file_strict_mmap,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300857 .splice_read = generic_file_splice_read,
858 .llseek = cifs_llseek,
859#ifdef CONFIG_CIFS_POSIX
860 .unlocked_ioctl = cifs_ioctl,
861#endif /* CONFIG_CIFS_POSIX */
862 .setlease = cifs_setlease,
863};
864
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800865const struct file_operations cifs_file_direct_ops = {
Pavel Shilovsky0b81c1c2011-03-10 10:11:05 +0300866 /* BB reevaluate whether they can be done with directio, no cache */
867 .read = do_sync_read,
868 .write = do_sync_write,
869 .aio_read = cifs_user_readv,
870 .aio_write = cifs_user_writev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 .open = cifs_open,
872 .release = cifs_close,
873 .lock = cifs_lock,
874 .fsync = cifs_fsync,
875 .flush = cifs_flush,
Steve Frencha994b8f2009-12-07 05:44:46 +0000876 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200877 .splice_read = generic_file_splice_read,
Steve Frenchc67593a2005-04-28 22:41:04 -0700878#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000879 .unlocked_ioctl = cifs_ioctl,
Steve Frenchc67593a2005-04-28 22:41:04 -0700880#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800881 .llseek = cifs_llseek,
Steve French84210e92008-10-23 04:42:37 +0000882 .setlease = cifs_setlease,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883};
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300884
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800885const struct file_operations cifs_file_nobrl_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800886 .read = do_sync_read,
887 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800888 .aio_read = generic_file_aio_read,
889 .aio_write = cifs_file_aio_write,
890 .open = cifs_open,
891 .release = cifs_close,
892 .fsync = cifs_fsync,
893 .flush = cifs_flush,
894 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200895 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800896 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800897#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000898 .unlocked_ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800899#endif /* CONFIG_CIFS_POSIX */
Steve French84210e92008-10-23 04:42:37 +0000900 .setlease = cifs_setlease,
Steve French8b94bcb2005-11-11 11:41:00 -0800901};
902
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300903const struct file_operations cifs_file_strict_nobrl_ops = {
904 .read = do_sync_read,
905 .write = do_sync_write,
Pavel Shilovskya70307e2010-12-14 11:50:41 +0300906 .aio_read = cifs_strict_readv,
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500907 .aio_write = cifs_strict_writev,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300908 .open = cifs_open,
909 .release = cifs_close,
910 .fsync = cifs_strict_fsync,
911 .flush = cifs_flush,
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +0300912 .mmap = cifs_file_strict_mmap,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +0300913 .splice_read = generic_file_splice_read,
914 .llseek = cifs_llseek,
915#ifdef CONFIG_CIFS_POSIX
916 .unlocked_ioctl = cifs_ioctl,
917#endif /* CONFIG_CIFS_POSIX */
918 .setlease = cifs_setlease,
919};
920
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800921const struct file_operations cifs_file_direct_nobrl_ops = {
Pavel Shilovsky0b81c1c2011-03-10 10:11:05 +0300922 /* BB reevaluate whether they can be done with directio, no cache */
923 .read = do_sync_read,
924 .write = do_sync_write,
925 .aio_read = cifs_user_readv,
926 .aio_write = cifs_user_writev,
Steve French87c89dd2005-11-17 17:03:00 -0800927 .open = cifs_open,
928 .release = cifs_close,
929 .fsync = cifs_fsync,
930 .flush = cifs_flush,
Pavel Shilovsky810627a02010-03-27 02:00:49 +0000931 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200932 .splice_read = generic_file_splice_read,
Steve French8b94bcb2005-11-11 11:41:00 -0800933#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000934 .unlocked_ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800935#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800936 .llseek = cifs_llseek,
Steve French84210e92008-10-23 04:42:37 +0000937 .setlease = cifs_setlease,
Steve French8b94bcb2005-11-11 11:41:00 -0800938};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800940const struct file_operations cifs_dir_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 .readdir = cifs_readdir,
942 .release = cifs_closedir,
943 .read = generic_read_dir,
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000944 .unlocked_ioctl = cifs_ioctl,
Christoph Hellwig3222a3e2008-09-03 21:53:01 +0200945 .llseek = generic_file_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946};
947
948static void
Alexey Dobriyan51cc5062008-07-25 19:45:34 -0700949cifs_init_once(void *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950{
951 struct cifsInodeInfo *cifsi = inode;
952
Christoph Lametera35afb82007-05-16 22:10:57 -0700953 inode_init_once(&cifsi->vfs_inode);
954 INIT_LIST_HEAD(&cifsi->lockList);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955}
956
957static int
958cifs_init_inodecache(void)
959{
960 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
Steve French26f57362007-08-30 22:09:15 +0000961 sizeof(struct cifsInodeInfo),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800962 0, (SLAB_RECLAIM_ACCOUNT|
963 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +0900964 cifs_init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 if (cifs_inode_cachep == NULL)
966 return -ENOMEM;
967
968 return 0;
969}
970
971static void
972cifs_destroy_inodecache(void)
973{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700974 kmem_cache_destroy(cifs_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975}
976
977static int
978cifs_init_request_bufs(void)
979{
Steve French4523cc32007-04-30 20:13:06 +0000980 if (CIFSMaxBufSize < 8192) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
982 Unicode path name has to fit in any SMB/CIFS path based frames */
983 CIFSMaxBufSize = 8192;
984 } else if (CIFSMaxBufSize > 1024*127) {
985 CIFSMaxBufSize = 1024 * 127;
986 } else {
987 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
988 }
Joe Perchesb6b38f72010-04-21 03:50:45 +0000989/* cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 cifs_req_cachep = kmem_cache_create("cifs_request",
991 CIFSMaxBufSize +
992 MAX_CIFS_HDR_SIZE, 0,
Paul Mundt20c2df82007-07-20 10:11:58 +0900993 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 if (cifs_req_cachep == NULL)
995 return -ENOMEM;
996
Steve French4523cc32007-04-30 20:13:06 +0000997 if (cifs_min_rcv < 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 cifs_min_rcv = 1;
999 else if (cifs_min_rcv > 64) {
1000 cifs_min_rcv = 64;
Joe Perchesb6b38f72010-04-21 03:50:45 +00001001 cERROR(1, "cifs_min_rcv set to maximum (64)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 }
1003
Matthew Dobson93d23412006-03-26 01:37:50 -08001004 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1005 cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006
Steve French4523cc32007-04-30 20:13:06 +00001007 if (cifs_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 kmem_cache_destroy(cifs_req_cachep);
1009 return -ENOMEM;
1010 }
Steve Frenchec637e32005-12-12 20:53:18 -08001011 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 almost all handle based requests (but not write response, nor is it
1013 sufficient for path based requests). A smaller size would have
Steve French50c2f752007-07-13 00:33:32 +00001014 been more efficient (compacting multiple slab items on one 4k page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 for the case in which debug was on, but this larger size allows
1016 more SMBs to use small buffer alloc and is still much more
Steve French6dc0f872007-07-06 23:13:06 +00001017 efficient to alloc 1 per page off the slab compared to 17K (5page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 alloc of large cifs buffers even when page debugging is on */
1019 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
Steve French6dc0f872007-07-06 23:13:06 +00001020 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +09001021 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 if (cifs_sm_req_cachep == NULL) {
1023 mempool_destroy(cifs_req_poolp);
1024 kmem_cache_destroy(cifs_req_cachep);
Steve French6dc0f872007-07-06 23:13:06 +00001025 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 }
1027
Steve French4523cc32007-04-30 20:13:06 +00001028 if (cifs_min_small < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 cifs_min_small = 2;
1030 else if (cifs_min_small > 256) {
1031 cifs_min_small = 256;
Joe Perchesb6b38f72010-04-21 03:50:45 +00001032 cFYI(1, "cifs_min_small set to maximum (256)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 }
1034
Matthew Dobson93d23412006-03-26 01:37:50 -08001035 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1036 cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037
Steve French4523cc32007-04-30 20:13:06 +00001038 if (cifs_sm_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 mempool_destroy(cifs_req_poolp);
1040 kmem_cache_destroy(cifs_req_cachep);
1041 kmem_cache_destroy(cifs_sm_req_cachep);
1042 return -ENOMEM;
1043 }
1044
1045 return 0;
1046}
1047
1048static void
1049cifs_destroy_request_bufs(void)
1050{
1051 mempool_destroy(cifs_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001052 kmem_cache_destroy(cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 mempool_destroy(cifs_sm_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001054 kmem_cache_destroy(cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055}
1056
1057static int
1058cifs_init_mids(void)
1059{
1060 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
Steve French26f57362007-08-30 22:09:15 +00001061 sizeof(struct mid_q_entry), 0,
1062 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 if (cifs_mid_cachep == NULL)
1064 return -ENOMEM;
1065
Matthew Dobson93d23412006-03-26 01:37:50 -08001066 /* 3 is a reasonable minimum number of simultaneous operations */
1067 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
Steve French4523cc32007-04-30 20:13:06 +00001068 if (cifs_mid_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 kmem_cache_destroy(cifs_mid_cachep);
1070 return -ENOMEM;
1071 }
1072
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 return 0;
1074}
1075
1076static void
1077cifs_destroy_mids(void)
1078{
1079 mempool_destroy(cifs_mid_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001080 kmem_cache_destroy(cifs_mid_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081}
1082
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083static int __init
1084init_cifs(void)
1085{
1086 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 cifs_proc_init();
Jeff Laytone7ddee92008-11-14 13:44:38 -05001088 INIT_LIST_HEAD(&cifs_tcp_ses_list);
Steve French0eff0e22011-02-24 05:39:23 +00001089#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
Steve French4ca9c192005-10-10 19:52:13 -07001090 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1091 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
Steve French0eff0e22011-02-24 05:39:23 +00001092#endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093/*
1094 * Initialize Global counters
1095 */
1096 atomic_set(&sesInfoAllocCount, 0);
1097 atomic_set(&tconInfoAllocCount, 0);
Steve French6dc0f872007-07-06 23:13:06 +00001098 atomic_set(&tcpSesAllocCount, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 atomic_set(&tcpSesReconnectCount, 0);
1100 atomic_set(&tconInfoReconnectCount, 0);
1101
1102 atomic_set(&bufAllocCount, 0);
Steve French4498eed52005-12-03 13:58:57 -08001103 atomic_set(&smBufAllocCount, 0);
1104#ifdef CONFIG_CIFS_STATS2
1105 atomic_set(&totBufAllocCount, 0);
1106 atomic_set(&totSmBufAllocCount, 0);
1107#endif /* CONFIG_CIFS_STATS2 */
1108
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 atomic_set(&midCount, 0);
1110 GlobalCurrentXid = 0;
1111 GlobalTotalActiveXid = 0;
1112 GlobalMaxActiveXid = 0;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301113 spin_lock_init(&cifs_tcp_ses_lock);
Jeff Layton44772882010-10-15 15:34:03 -04001114 spin_lock_init(&cifs_file_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 spin_lock_init(&GlobalMid_Lock);
1116
Steve French4523cc32007-04-30 20:13:06 +00001117 if (cifs_max_pending < 2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 cifs_max_pending = 2;
Joe Perchesb6b38f72010-04-21 03:50:45 +00001119 cFYI(1, "cifs_max_pending set to min of 2");
Steve French4523cc32007-04-30 20:13:06 +00001120 } else if (cifs_max_pending > 256) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 cifs_max_pending = 256;
Joe Perchesb6b38f72010-04-21 03:50:45 +00001122 cFYI(1, "cifs_max_pending set to max of 256");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 }
1124
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301125 rc = cifs_fscache_register();
1126 if (rc)
Steve Frenchd3bf5222010-09-22 19:15:36 +00001127 goto out_clean_proc;
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301128
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 rc = cifs_init_inodecache();
Steve French45af7a02006-04-21 22:52:25 +00001130 if (rc)
Steve Frenchd3bf5222010-09-22 19:15:36 +00001131 goto out_unreg_fscache;
Steve French45af7a02006-04-21 22:52:25 +00001132
1133 rc = cifs_init_mids();
1134 if (rc)
1135 goto out_destroy_inodecache;
1136
1137 rc = cifs_init_request_bufs();
1138 if (rc)
1139 goto out_destroy_mids;
1140
Jeff Layton84a15b92007-11-03 05:02:24 +00001141#ifdef CONFIG_CIFS_UPCALL
1142 rc = register_key_type(&cifs_spnego_key_type);
1143 if (rc)
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001144 goto out_destroy_request_bufs;
1145#endif /* CONFIG_CIFS_UPCALL */
1146
1147#ifdef CONFIG_CIFS_ACL
1148 rc = init_cifs_idmap();
1149 if (rc)
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001150 goto out_register_key_type;
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001151#endif /* CONFIG_CIFS_ACL */
1152
1153 rc = register_filesystem(&cifs_fs_type);
1154 if (rc)
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001155 goto out_init_cifs_idmap;
Steve French45af7a02006-04-21 22:52:25 +00001156
Steve French45af7a02006-04-21 22:52:25 +00001157 return 0;
1158
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001159out_init_cifs_idmap:
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001160#ifdef CONFIG_CIFS_ACL
1161 exit_cifs_idmap();
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001162out_register_key_type:
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001163#endif
1164#ifdef CONFIG_CIFS_UPCALL
1165 unregister_key_type(&cifs_spnego_key_type);
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001166out_destroy_request_bufs:
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001167#endif
Steve French45af7a02006-04-21 22:52:25 +00001168 cifs_destroy_request_bufs();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001169out_destroy_mids:
Steve French45af7a02006-04-21 22:52:25 +00001170 cifs_destroy_mids();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001171out_destroy_inodecache:
Steve French45af7a02006-04-21 22:52:25 +00001172 cifs_destroy_inodecache();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001173out_unreg_fscache:
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301174 cifs_fscache_unregister();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001175out_clean_proc:
1176 cifs_proc_clean();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 return rc;
1178}
1179
1180static void __exit
1181exit_cifs(void)
1182{
Joe Perchesb6b38f72010-04-21 03:50:45 +00001183 cFYI(DBG2, "exit_cifs");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 cifs_proc_clean();
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301185 cifs_fscache_unregister();
Steve French61033352008-01-09 16:21:36 +00001186#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov78d31a32008-04-24 12:56:07 +04001187 cifs_dfs_release_automount_timer();
Steve French61033352008-01-09 16:21:36 +00001188#endif
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001189#ifdef CONFIG_CIFS_ACL
1190 cifs_destroy_idmaptrees();
1191 exit_cifs_idmap();
1192#endif
Jeff Layton84a15b92007-11-03 05:02:24 +00001193#ifdef CONFIG_CIFS_UPCALL
1194 unregister_key_type(&cifs_spnego_key_type);
1195#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 unregister_filesystem(&cifs_fs_type);
1197 cifs_destroy_inodecache();
1198 cifs_destroy_mids();
1199 cifs_destroy_request_bufs();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200}
1201
1202MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
Steve French6dc0f872007-07-06 23:13:06 +00001203MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204MODULE_DESCRIPTION
Steve French63135e02007-07-17 17:34:02 +00001205 ("VFS to access servers complying with the SNIA CIFS Specification "
1206 "e.g. Samba and Windows");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207MODULE_VERSION(CIFS_VERSION);
1208module_init(init_cifs)
1209module_exit(exit_cifs)