blob: 3936aa7f2c2285cfb59857f8fe1925528920543a [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;
56unsigned int experimEnabled = 0;
57unsigned 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");
Linus Torvalds1da177e2005-04-16 15:20:36 -070080
Linus Torvalds1da177e2005-04-16 15:20:36 -070081extern mempool_t *cifs_sm_req_poolp;
82extern mempool_t *cifs_req_poolp;
83extern mempool_t *cifs_mid_poolp;
84
Jeff Laytond7c86ff2010-10-11 15:07:19 -040085void
86cifs_sb_active(struct super_block *sb)
87{
88 struct cifs_sb_info *server = CIFS_SB(sb);
89
90 if (atomic_inc_return(&server->active) == 1)
91 atomic_inc(&sb->s_active);
92}
93
94void
95cifs_sb_deactive(struct super_block *sb)
96{
97 struct cifs_sb_info *server = CIFS_SB(sb);
98
99 if (atomic_dec_and_test(&server->active))
100 deactivate_super(sb);
101}
102
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103static int
104cifs_read_super(struct super_block *sb, void *data,
105 const char *devname, int silent)
106{
107 struct inode *inode;
108 struct cifs_sb_info *cifs_sb;
109 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +0000110
Steve French1b2b2122007-02-17 04:30:54 +0000111 /* BB should we make this contingent on mount parm? */
112 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
Steve French790fe572007-07-07 19:25:05 +0000113 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 cifs_sb = CIFS_SB(sb);
Steve French4523cc32007-04-30 20:13:06 +0000115 if (cifs_sb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
Jeff Layton0dd12c22010-10-08 12:20:12 -0400118 spin_lock_init(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -0400119 cifs_sb->tlink_tree = RB_ROOT;
Jeff Layton0dd12c22010-10-08 12:20:12 -0400120
Jens Axboe8044f7f2010-04-22 12:09:48 +0200121 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
122 if (rc) {
123 kfree(cifs_sb);
124 return rc;
125 }
126
Igor Mammedove6ab1582008-01-11 01:49:48 +0000127#ifdef CONFIG_CIFS_DFS_UPCALL
128 /* copy mount params to sb for use in submounts */
129 /* BB: should we move this after the mount so we
130 * do not have to do the copy on failed mounts?
131 * BB: May be it is better to do simple copy before
132 * complex operation (mount), and in case of fail
133 * just exit instead of doing mount and attempting
134 * undo it if this copy fails?*/
Steve French79ee9a82008-06-10 21:37:02 +0000135 if (data) {
136 int len = strlen(data);
137 cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
138 if (cifs_sb->mountdata == NULL) {
Jens Axboe8044f7f2010-04-22 12:09:48 +0200139 bdi_destroy(&cifs_sb->bdi);
Steve French79ee9a82008-06-10 21:37:02 +0000140 kfree(sb->s_fs_info);
141 sb->s_fs_info = NULL;
142 return -ENOMEM;
143 }
144 strncpy(cifs_sb->mountdata, data, len + 1);
145 cifs_sb->mountdata[len] = '\0';
Igor Mammedove6ab1582008-01-11 01:49:48 +0000146 }
Igor Mammedove6ab1582008-01-11 01:49:48 +0000147#endif
148
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 rc = cifs_mount(sb, cifs_sb, data, devname);
150
151 if (rc) {
152 if (!silent)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000153 cERROR(1, "cifs_mount failed w/return code = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 goto out_mount_failed;
155 }
156
157 sb->s_magic = CIFS_MAGIC_NUMBER;
158 sb->s_op = &cifs_super_ops;
Jens Axboe8044f7f2010-04-22 12:09:48 +0200159 sb->s_bdi = &cifs_sb->bdi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 sb->s_blocksize = CIFS_MAX_MSGSIZE;
161 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
Jeff Laytonbd433d42009-05-27 09:37:34 -0400162 inode = cifs_root_iget(sb, ROOT_I);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163
David Howellsce634ab2008-02-07 00:15:33 -0800164 if (IS_ERR(inode)) {
165 rc = PTR_ERR(inode);
166 inode = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 goto out_no_root;
168 }
169
170 sb->s_root = d_alloc_root(inode);
171
172 if (!sb->s_root) {
173 rc = -ENOMEM;
174 goto out_no_root;
175 }
Steve French50c2f752007-07-13 00:33:32 +0000176
Steve French7521a3c2007-07-11 18:30:34 +0000177#ifdef CONFIG_CIFS_EXPERIMENTAL
178 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000179 cFYI(1, "export ops supported");
Steve French7521a3c2007-07-11 18:30:34 +0000180 sb->s_export_op = &cifs_export_ops;
181 }
182#endif /* EXPERIMENTAL */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
184 return 0;
185
186out_no_root:
Joe Perchesb6b38f72010-04-21 03:50:45 +0000187 cERROR(1, "cifs_read_super: get root inode failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 if (inode)
189 iput(inode);
Steve French54b46022008-08-11 22:31:40 +0000190
Steve French2c731af2008-08-11 22:28:53 +0000191 cifs_umount(sb, cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
193out_mount_failed:
Steve French4523cc32007-04-30 20:13:06 +0000194 if (cifs_sb) {
Igor Mammedove6ab1582008-01-11 01:49:48 +0000195#ifdef CONFIG_CIFS_DFS_UPCALL
196 if (cifs_sb->mountdata) {
197 kfree(cifs_sb->mountdata);
198 cifs_sb->mountdata = NULL;
199 }
200#endif
Thomas Gleixner6d729e42009-08-16 21:05:08 +0000201 unload_nls(cifs_sb->local_nls);
Jens Axboe8044f7f2010-04-22 12:09:48 +0200202 bdi_destroy(&cifs_sb->bdi);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 kfree(cifs_sb);
204 }
205 return rc;
206}
207
208static void
209cifs_put_super(struct super_block *sb)
210{
211 int rc = 0;
212 struct cifs_sb_info *cifs_sb;
213
Joe Perchesb6b38f72010-04-21 03:50:45 +0000214 cFYI(1, "In cifs_put_super");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 cifs_sb = CIFS_SB(sb);
Steve French4523cc32007-04-30 20:13:06 +0000216 if (cifs_sb == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000217 cFYI(1, "Empty cifs superblock info passed to unmount");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 return;
219 }
Christoph Hellwig6cfd0142009-05-05 15:40:36 +0200220
Steve French790fe572007-07-07 19:25:05 +0000221 rc = cifs_umount(sb, cifs_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +0000222 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000223 cERROR(1, "cifs_umount failed with return code %d", rc);
Igor Mammedove6ab1582008-01-11 01:49:48 +0000224#ifdef CONFIG_CIFS_DFS_UPCALL
225 if (cifs_sb->mountdata) {
226 kfree(cifs_sb->mountdata);
227 cifs_sb->mountdata = NULL;
228 }
229#endif
230
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 unload_nls(cifs_sb->local_nls);
Jens Axboe8044f7f2010-04-22 12:09:48 +0200232 bdi_destroy(&cifs_sb->bdi);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 kfree(cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234}
235
236static int
David Howells726c3342006-06-23 02:02:58 -0700237cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238{
David Howells726c3342006-06-23 02:02:58 -0700239 struct super_block *sb = dentry->d_sb;
Steve French39da9842008-04-28 04:04:34 +0000240 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Layton0d424ad2010-09-20 16:01:35 -0700241 struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
Steve Frenchc81156d2005-04-28 22:41:07 -0700242 int rc = -EOPNOTSUPP;
Steve French39da9842008-04-28 04:04:34 +0000243 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
245 xid = GetXid();
246
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 buf->f_type = CIFS_MAGIC_NUMBER;
248
Steve French39da9842008-04-28 04:04:34 +0000249 /*
250 * PATH_MAX may be too long - it would presumably be total path,
251 * but note that some servers (includinng Samba 3) have a shorter
252 * maximum path.
253 *
254 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
255 */
256 buf->f_namelen = PATH_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 buf->f_files = 0; /* undefined */
258 buf->f_ffree = 0; /* unlimited */
259
Steve French39da9842008-04-28 04:04:34 +0000260 /*
261 * We could add a second check for a QFS Unix capability bit
262 */
263 if ((tcon->ses->capabilities & CAP_UNIX) &&
264 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
265 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266
Steve French39da9842008-04-28 04:04:34 +0000267 /*
268 * Only need to call the old QFSInfo if failed on newer one,
269 * e.g. by OS/2.
270 **/
271 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
272 rc = CIFSSMBQFSInfo(xid, tcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
Steve French39da9842008-04-28 04:04:34 +0000274 /*
275 * Some old Windows servers also do not support level 103, retry with
276 * older level one if old server failed the previous call or we
277 * bypassed it because we detected that this was an older LANMAN sess
278 */
Steve French4523cc32007-04-30 20:13:06 +0000279 if (rc)
Steve French39da9842008-04-28 04:04:34 +0000280 rc = SMBOldQFSInfo(xid, tcon, buf);
281
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 FreeXid(xid);
Steve French39da9842008-04-28 04:04:34 +0000283 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284}
285
Al Viroe6305c42008-07-15 21:03:57 -0400286static int cifs_permission(struct inode *inode, int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287{
288 struct cifs_sb_info *cifs_sb;
289
290 cifs_sb = CIFS_SB(inode->i_sb);
291
Miklos Szeredif696a362008-07-31 13:41:58 +0200292 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
293 if ((mask & MAY_EXEC) && !execute_ok(inode))
294 return -EACCES;
295 else
296 return 0;
297 } else /* file mode might have been restricted at mount time
Steve French50c2f752007-07-13 00:33:32 +0000298 on the client (above and beyond ACL on servers) for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 servers which do not support setting and viewing mode bits,
Steve French50c2f752007-07-13 00:33:32 +0000300 so allowing client to check permissions is useful */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 return generic_permission(inode, mask, NULL);
302}
303
Christoph Lametere18b8902006-12-06 20:33:20 -0800304static struct kmem_cache *cifs_inode_cachep;
305static struct kmem_cache *cifs_req_cachep;
306static struct kmem_cache *cifs_mid_cachep;
Christoph Lametere18b8902006-12-06 20:33:20 -0800307static struct kmem_cache *cifs_sm_req_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308mempool_t *cifs_sm_req_poolp;
309mempool_t *cifs_req_poolp;
310mempool_t *cifs_mid_poolp;
311
312static struct inode *
313cifs_alloc_inode(struct super_block *sb)
314{
315 struct cifsInodeInfo *cifs_inode;
Christoph Lametere94b1762006-12-06 20:33:17 -0800316 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 if (!cifs_inode)
318 return NULL;
319 cifs_inode->cifsAttrs = 0x20; /* default */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 cifs_inode->time = 0;
321 /* Until the file is open and we have gotten oplock
322 info back from the server, can not assume caching of
323 file data or metadata */
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300324 cifs_set_oplock_level(cifs_inode, 0);
Jeff Layton9a8165f2008-10-17 21:03:20 -0400325 cifs_inode->delete_pending = false;
Jeff Laytondf2cf172010-02-12 07:44:16 -0500326 cifs_inode->invalid_mapping = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400328 cifs_inode->server_eof = 0;
Steve French50c2f752007-07-13 00:33:32 +0000329
Steve French1b2b2122007-02-17 04:30:54 +0000330 /* Can not set i_flags here - they get immediately overwritten
331 to zero by the VFS */
332/* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 INIT_LIST_HEAD(&cifs_inode->openFileList);
334 return &cifs_inode->vfs_inode;
335}
336
337static void
338cifs_destroy_inode(struct inode *inode)
339{
340 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
341}
342
Jeff Layton61f98ff2009-06-11 10:27:32 -0400343static void
Al Virob57922d2010-06-07 14:34:48 -0400344cifs_evict_inode(struct inode *inode)
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530345{
Al Virob57922d2010-06-07 14:34:48 -0400346 truncate_inode_pages(&inode->i_data, 0);
347 end_writeback(inode);
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530348 cifs_fscache_release_inode_cookie(inode);
349}
350
351static void
Jeff Layton61f98ff2009-06-11 10:27:32 -0400352cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
353{
354 seq_printf(s, ",addr=");
355
356 switch (server->addr.sockAddr.sin_family) {
357 case AF_INET:
358 seq_printf(s, "%pI4", &server->addr.sockAddr.sin_addr.s_addr);
359 break;
360 case AF_INET6:
361 seq_printf(s, "%pI6",
362 &server->addr.sockAddr6.sin6_addr.s6_addr);
363 if (server->addr.sockAddr6.sin6_scope_id)
364 seq_printf(s, "%%%u",
365 server->addr.sockAddr6.sin6_scope_id);
366 break;
367 default:
368 seq_printf(s, "(unknown)");
369 }
370}
371
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372/*
373 * cifs_show_options() is for displaying mount options in /proc/mounts.
374 * Not all settable options are displayed but most of the important
375 * ones are.
376 */
377static int
378cifs_show_options(struct seq_file *s, struct vfsmount *m)
379{
Jeff Layton8e047d02009-08-28 10:11:10 -0400380 struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
Jeff Layton0d424ad2010-09-20 16:01:35 -0700381 struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
Ben Greear3eb9a882010-09-01 17:06:02 -0700382 struct sockaddr *srcaddr;
383 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
Jeff Layton8e047d02009-08-28 10:11:10 -0400385 seq_printf(s, ",unc=%s", tcon->treeName);
Jeff Layton29e07c82010-09-29 19:51:12 -0400386
387 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
388 seq_printf(s, ",multiuser");
389 else if (tcon->ses->userName)
Jeff Layton8616e0f2009-06-11 10:27:28 -0400390 seq_printf(s, ",username=%s", tcon->ses->userName);
Jeff Layton29e07c82010-09-29 19:51:12 -0400391
Jeff Layton8616e0f2009-06-11 10:27:28 -0400392 if (tcon->ses->domainName)
393 seq_printf(s, ",domain=%s", tcon->ses->domainName);
394
Ben Greear3eb9a882010-09-01 17:06:02 -0700395 if (srcaddr->sa_family != AF_UNSPEC) {
396 struct sockaddr_in *saddr4;
397 struct sockaddr_in6 *saddr6;
398 saddr4 = (struct sockaddr_in *)srcaddr;
399 saddr6 = (struct sockaddr_in6 *)srcaddr;
400 if (srcaddr->sa_family == AF_INET6)
401 seq_printf(s, ",srcaddr=%pI6c",
402 &saddr6->sin6_addr);
403 else if (srcaddr->sa_family == AF_INET)
404 seq_printf(s, ",srcaddr=%pI4",
405 &saddr4->sin_addr.s_addr);
406 else
407 seq_printf(s, ",srcaddr=BAD-AF:%i",
408 (int)(srcaddr->sa_family));
409 }
410
Jeff Layton8616e0f2009-06-11 10:27:28 -0400411 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
Jeff Layton340481a32009-06-11 10:27:29 -0400412 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
413 seq_printf(s, ",forceuid");
Jeff Layton4486d6e2009-08-03 12:45:10 -0400414 else
415 seq_printf(s, ",noforceuid");
Jeff Layton340481a32009-06-11 10:27:29 -0400416
Jeff Layton8616e0f2009-06-11 10:27:28 -0400417 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
Jeff Layton340481a32009-06-11 10:27:29 -0400418 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
419 seq_printf(s, ",forcegid");
Jeff Layton4486d6e2009-08-03 12:45:10 -0400420 else
421 seq_printf(s, ",noforcegid");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400422
Jeff Layton61f98ff2009-06-11 10:27:32 -0400423 cifs_show_address(s, tcon->ses->server);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400424
425 if (!tcon->unix_ext)
426 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
Steve French2b280fa2008-05-17 03:12:45 +0000427 cifs_sb->mnt_file_mode,
428 cifs_sb->mnt_dir_mode);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400429 if (tcon->seal)
430 seq_printf(s, ",seal");
431 if (tcon->nocase)
432 seq_printf(s, ",nocase");
433 if (tcon->retry)
434 seq_printf(s, ",hard");
435 if (cifs_sb->prepath)
436 seq_printf(s, ",prepath=%s", cifs_sb->prepath);
437 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
438 seq_printf(s, ",posixpaths");
439 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
440 seq_printf(s, ",setuids");
441 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
442 seq_printf(s, ",serverino");
443 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
444 seq_printf(s, ",directio");
445 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
446 seq_printf(s, ",nouser_xattr");
447 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
448 seq_printf(s, ",mapchars");
449 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
450 seq_printf(s, ",sfu");
451 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
452 seq_printf(s, ",nobrl");
453 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
454 seq_printf(s, ",cifsacl");
455 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
456 seq_printf(s, ",dynperm");
457 if (m->mnt_sb->s_flags & MS_POSIXACL)
458 seq_printf(s, ",acl");
Stefan Metzmacher736a3322010-07-30 14:56:00 +0200459 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
460 seq_printf(s, ",mfsymlinks");
Suresh Jayaraman476428f2010-11-24 17:49:07 +0530461 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
462 seq_printf(s, ",fsc");
Steve French2b280fa2008-05-17 03:12:45 +0000463
Jeff Layton8616e0f2009-06-11 10:27:28 -0400464 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
465 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
Suresh Jayaraman6d20e842010-12-01 14:42:28 +0530466 /* convert actimeo and display it in seconds */
467 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400468
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 return 0;
470}
471
Al Viro42faad92008-04-24 07:21:56 -0400472static void cifs_umount_begin(struct super_block *sb)
Steve French68058e72005-10-10 10:34:22 -0700473{
Al Viro42faad92008-04-24 07:21:56 -0400474 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French50c2f752007-07-13 00:33:32 +0000475 struct cifsTconInfo *tcon;
Steve French68058e72005-10-10 10:34:22 -0700476
Steve French4523cc32007-04-30 20:13:06 +0000477 if (cifs_sb == NULL)
Steve French9e2e85f2005-10-10 14:28:38 -0700478 return;
479
Jeff Layton0d424ad2010-09-20 16:01:35 -0700480 tcon = cifs_sb_master_tcon(cifs_sb);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500481
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530482 spin_lock(&cifs_tcp_ses_lock);
Steve Frenchad8034f2009-06-26 03:25:49 +0000483 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
484 /* we have other mounts to same share or we have
485 already tried to force umount this and woken up
486 all waiting network requests, nothing to do */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530487 spin_unlock(&cifs_tcp_ses_lock);
Steve Frenchad8034f2009-06-26 03:25:49 +0000488 return;
489 } else if (tcon->tc_count == 1)
Steve French5e1253b2005-10-10 14:06:37 -0700490 tcon->tidStatus = CifsExiting;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530491 spin_unlock(&cifs_tcp_ses_lock);
Steve French5e1253b2005-10-10 14:06:37 -0700492
Steve French3a5ff612006-07-14 22:37:11 +0000493 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
Steve French7b7abfe2005-11-09 15:21:09 -0800494 /* cancel_notify_requests(tcon); */
Steve French50c2f752007-07-13 00:33:32 +0000495 if (tcon->ses && tcon->ses->server) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000496 cFYI(1, "wake up tasks now - umount begin not complete");
Steve French9e2e85f2005-10-10 14:28:38 -0700497 wake_up_all(&tcon->ses->server->request_q);
Steve French6ab16d22005-11-29 20:55:11 -0800498 wake_up_all(&tcon->ses->server->response_q);
499 msleep(1); /* yield */
500 /* we have to kick the requests once more */
501 wake_up_all(&tcon->ses->server->response_q);
502 msleep(1);
Steve French5e1253b2005-10-10 14:06:37 -0700503 }
Steve French68058e72005-10-10 10:34:22 -0700504
505 return;
506}
Steve French68058e72005-10-10 10:34:22 -0700507
Steve Frenchbf97d282006-09-28 21:34:06 +0000508#ifdef CONFIG_CIFS_STATS2
509static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
510{
511 /* BB FIXME */
512 return 0;
513}
514#endif
515
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516static int cifs_remount(struct super_block *sb, int *flags, char *data)
517{
518 *flags |= MS_NODIRATIME;
519 return 0;
520}
521
Al Viro45321ac2010-06-07 13:43:19 -0400522static int cifs_drop_inode(struct inode *inode)
Jeff Layton12420ac2010-06-01 14:47:40 -0400523{
524 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
525
Al Viro45321ac2010-06-07 13:43:19 -0400526 /* no serverino => unconditional eviction */
527 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
528 generic_drop_inode(inode);
Jeff Layton12420ac2010-06-01 14:47:40 -0400529}
530
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800531static const struct super_operations cifs_super_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 .put_super = cifs_put_super,
533 .statfs = cifs_statfs,
534 .alloc_inode = cifs_alloc_inode,
535 .destroy_inode = cifs_destroy_inode,
Jeff Layton12420ac2010-06-01 14:47:40 -0400536 .drop_inode = cifs_drop_inode,
Al Virob57922d2010-06-07 14:34:48 -0400537 .evict_inode = cifs_evict_inode,
Jeff Layton12420ac2010-06-01 14:47:40 -0400538/* .delete_inode = cifs_delete_inode, */ /* Do not need above
539 function unless later we add lazy close of inodes or unless the
Steve French50c2f752007-07-13 00:33:32 +0000540 kernel forgets to call us with the same number of releases (closes)
541 as opens */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 .show_options = cifs_show_options,
Steve French7b7abfe2005-11-09 15:21:09 -0800543 .umount_begin = cifs_umount_begin,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 .remount_fs = cifs_remount,
Steve Frenchbf97d282006-09-28 21:34:06 +0000545#ifdef CONFIG_CIFS_STATS2
Steve Frenchf46d3e12006-09-30 01:08:55 +0000546 .show_stats = cifs_show_stats,
Steve Frenchbf97d282006-09-28 21:34:06 +0000547#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548};
549
Al Virod753ed92010-07-26 12:52:33 +0400550static struct dentry *
551cifs_do_mount(struct file_system_type *fs_type,
552 int flags, const char *dev_name, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553{
554 int rc;
Jan Blunckdb719222010-08-15 22:51:10 +0200555 struct super_block *sb;
556
Jan Blunckdb719222010-08-15 22:51:10 +0200557 sb = sget(fs_type, NULL, set_anon_super, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558
Joe Perchesb6b38f72010-04-21 03:50:45 +0000559 cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560
Jan Blunckb0991aa2010-02-24 13:25:29 +0100561 if (IS_ERR(sb))
Al Virod753ed92010-07-26 12:52:33 +0400562 return ERR_CAST(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
564 sb->s_flags = flags;
565
Theodore Ts'o9b04c992006-03-24 03:15:10 -0800566 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 if (rc) {
Al Viro6f5bbff2009-05-06 01:34:22 -0400568 deactivate_locked_super(sb);
Al Virod753ed92010-07-26 12:52:33 +0400569 return ERR_PTR(rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 }
571 sb->s_flags |= MS_ACTIVE;
Al Virod753ed92010-07-26 12:52:33 +0400572 return dget(sb->s_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573}
574
Badari Pulavarty027445c2006-09-30 23:28:46 -0700575static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
576 unsigned long nr_segs, loff_t pos)
Steve French87c89dd2005-11-17 17:03:00 -0800577{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800578 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
Steve French87c89dd2005-11-17 17:03:00 -0800579 ssize_t written;
580
Badari Pulavarty027445c2006-09-30 23:28:46 -0700581 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
Steve French87c89dd2005-11-17 17:03:00 -0800582 if (!CIFS_I(inode)->clientCanCacheAll)
583 filemap_fdatawrite(inode->i_mapping);
584 return written;
585}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586
Steve Frenchc32a0b62006-01-12 14:41:28 -0800587static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
588{
589 /* origin == SEEK_END => we must revalidate the cached file length */
Steve French0889a942006-09-23 22:11:07 +0000590 if (origin == SEEK_END) {
Steve French030e9d82007-02-01 04:27:59 +0000591 int retval;
592
593 /* some applications poll for the file length in this strange
594 way so we must seek to end on non-oplocked files by
595 setting the revalidate time to zero */
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000596 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
Steve French030e9d82007-02-01 04:27:59 +0000597
Jeff Laytonabab0952010-02-12 07:44:18 -0500598 retval = cifs_revalidate_file(file);
Steve Frenchc32a0b62006-01-12 14:41:28 -0800599 if (retval < 0)
600 return (loff_t)retval;
601 }
Andi Kleen9465efc2008-06-27 11:05:24 +0200602 return generic_file_llseek_unlocked(file, offset, origin);
Steve Frenchc32a0b62006-01-12 14:41:28 -0800603}
604
Steve French84210e92008-10-23 04:42:37 +0000605static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
606{
Arnd Bergmannb89f4322010-09-18 15:09:31 +0200607 /* note that this is called by vfs setlease with lock_flocks held
608 to protect *lease from going away */
Steve French84210e92008-10-23 04:42:37 +0000609 struct inode *inode = file->f_path.dentry->d_inode;
Jeff Laytonba00ba62010-09-20 16:01:31 -0700610 struct cifsFileInfo *cfile = file->private_data;
Steve French84210e92008-10-23 04:42:37 +0000611
612 if (!(S_ISREG(inode->i_mode)))
613 return -EINVAL;
614
615 /* check if file is oplocked */
616 if (((arg == F_RDLCK) &&
617 (CIFS_I(inode)->clientCanCacheRead)) ||
618 ((arg == F_WRLCK) &&
619 (CIFS_I(inode)->clientCanCacheAll)))
620 return generic_setlease(file, arg, lease);
Jeff Layton13cfb732010-09-29 19:51:11 -0400621 else if (tlink_tcon(cfile->tlink)->local_lease &&
622 !CIFS_I(inode)->clientCanCacheRead)
Steve French84210e92008-10-23 04:42:37 +0000623 /* If the server claims to support oplock on this
624 file, then we still need to check oplock even
625 if the local_lease mount option is set, but there
626 are servers which do not support oplock for which
627 this mount option may be useful if the user
628 knows that the file won't be changed on the server
629 by anyone else */
630 return generic_setlease(file, arg, lease);
Christoph Hellwig51ee4b82010-10-31 08:35:10 -0400631 else
Steve French84210e92008-10-23 04:42:37 +0000632 return -EAGAIN;
633}
Steve French84210e92008-10-23 04:42:37 +0000634
Igor Mammedove6ab1582008-01-11 01:49:48 +0000635struct file_system_type cifs_fs_type = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 .owner = THIS_MODULE,
637 .name = "cifs",
Al Virod753ed92010-07-26 12:52:33 +0400638 .mount = cifs_do_mount,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 .kill_sb = kill_anon_super,
640 /* .fs_flags */
641};
Arjan van de Ven754661f2007-02-12 00:55:38 -0800642const struct inode_operations cifs_dir_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 .create = cifs_create,
644 .lookup = cifs_lookup,
645 .getattr = cifs_getattr,
646 .unlink = cifs_unlink,
647 .link = cifs_hardlink,
648 .mkdir = cifs_mkdir,
649 .rmdir = cifs_rmdir,
650 .rename = cifs_rename,
651 .permission = cifs_permission,
652/* revalidate:cifs_revalidate, */
653 .setattr = cifs_setattr,
654 .symlink = cifs_symlink,
655 .mknod = cifs_mknod,
656#ifdef CONFIG_CIFS_XATTR
657 .setxattr = cifs_setxattr,
658 .getxattr = cifs_getxattr,
659 .listxattr = cifs_listxattr,
660 .removexattr = cifs_removexattr,
661#endif
662};
663
Arjan van de Ven754661f2007-02-12 00:55:38 -0800664const struct inode_operations cifs_file_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665/* revalidate:cifs_revalidate, */
666 .setattr = cifs_setattr,
667 .getattr = cifs_getattr, /* do we need this anymore? */
668 .rename = cifs_rename,
669 .permission = cifs_permission,
670#ifdef CONFIG_CIFS_XATTR
671 .setxattr = cifs_setxattr,
672 .getxattr = cifs_getxattr,
673 .listxattr = cifs_listxattr,
674 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000675#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676};
677
Arjan van de Ven754661f2007-02-12 00:55:38 -0800678const struct inode_operations cifs_symlink_inode_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000679 .readlink = generic_readlink,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 .follow_link = cifs_follow_link,
681 .put_link = cifs_put_link,
682 .permission = cifs_permission,
683 /* BB add the following two eventually */
684 /* revalidate: cifs_revalidate,
685 setattr: cifs_notify_change, *//* BB do we need notify change */
686#ifdef CONFIG_CIFS_XATTR
687 .setxattr = cifs_setxattr,
688 .getxattr = cifs_getxattr,
689 .listxattr = cifs_listxattr,
690 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000691#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692};
693
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800694const struct file_operations cifs_file_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800695 .read = do_sync_read,
696 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800697 .aio_read = generic_file_aio_read,
698 .aio_write = cifs_file_aio_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 .open = cifs_open,
700 .release = cifs_close,
701 .lock = cifs_lock,
702 .fsync = cifs_fsync,
703 .flush = cifs_flush,
704 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200705 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800706 .llseek = cifs_llseek,
Steve Frenchc67593a2005-04-28 22:41:04 -0700707#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000708 .unlocked_ioctl = cifs_ioctl,
Steve Frenchc67593a2005-04-28 22:41:04 -0700709#endif /* CONFIG_CIFS_POSIX */
Steve French84210e92008-10-23 04:42:37 +0000710 .setlease = cifs_setlease,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711};
712
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800713const struct file_operations cifs_file_direct_ops = {
Steve Frencha994b8f2009-12-07 05:44:46 +0000714 /* no aio, no readv -
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 BB reevaluate whether they can be done with directio, no cache */
716 .read = cifs_user_read,
717 .write = cifs_user_write,
718 .open = cifs_open,
719 .release = cifs_close,
720 .lock = cifs_lock,
721 .fsync = cifs_fsync,
722 .flush = cifs_flush,
Steve Frencha994b8f2009-12-07 05:44:46 +0000723 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200724 .splice_read = generic_file_splice_read,
Steve Frenchc67593a2005-04-28 22:41:04 -0700725#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000726 .unlocked_ioctl = cifs_ioctl,
Steve Frenchc67593a2005-04-28 22:41:04 -0700727#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800728 .llseek = cifs_llseek,
Steve French84210e92008-10-23 04:42:37 +0000729 .setlease = cifs_setlease,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730};
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800731const struct file_operations cifs_file_nobrl_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800732 .read = do_sync_read,
733 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800734 .aio_read = generic_file_aio_read,
735 .aio_write = cifs_file_aio_write,
736 .open = cifs_open,
737 .release = cifs_close,
738 .fsync = cifs_fsync,
739 .flush = cifs_flush,
740 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200741 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800742 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800743#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000744 .unlocked_ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800745#endif /* CONFIG_CIFS_POSIX */
Steve French84210e92008-10-23 04:42:37 +0000746 .setlease = cifs_setlease,
Steve French8b94bcb2005-11-11 11:41:00 -0800747};
748
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800749const struct file_operations cifs_file_direct_nobrl_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000750 /* no mmap, no aio, no readv -
Steve French87c89dd2005-11-17 17:03:00 -0800751 BB reevaluate whether they can be done with directio, no cache */
752 .read = cifs_user_read,
753 .write = cifs_user_write,
754 .open = cifs_open,
755 .release = cifs_close,
756 .fsync = cifs_fsync,
757 .flush = cifs_flush,
Pavel Shilovsky810627a02010-03-27 02:00:49 +0000758 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200759 .splice_read = generic_file_splice_read,
Steve French8b94bcb2005-11-11 11:41:00 -0800760#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000761 .unlocked_ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800762#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800763 .llseek = cifs_llseek,
Steve French84210e92008-10-23 04:42:37 +0000764 .setlease = cifs_setlease,
Steve French8b94bcb2005-11-11 11:41:00 -0800765};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800767const struct file_operations cifs_dir_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 .readdir = cifs_readdir,
769 .release = cifs_closedir,
770 .read = generic_read_dir,
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000771 .unlocked_ioctl = cifs_ioctl,
Christoph Hellwig3222a3e2008-09-03 21:53:01 +0200772 .llseek = generic_file_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773};
774
775static void
Alexey Dobriyan51cc5062008-07-25 19:45:34 -0700776cifs_init_once(void *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777{
778 struct cifsInodeInfo *cifsi = inode;
779
Christoph Lametera35afb82007-05-16 22:10:57 -0700780 inode_init_once(&cifsi->vfs_inode);
781 INIT_LIST_HEAD(&cifsi->lockList);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782}
783
784static int
785cifs_init_inodecache(void)
786{
787 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
Steve French26f57362007-08-30 22:09:15 +0000788 sizeof(struct cifsInodeInfo),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800789 0, (SLAB_RECLAIM_ACCOUNT|
790 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +0900791 cifs_init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 if (cifs_inode_cachep == NULL)
793 return -ENOMEM;
794
795 return 0;
796}
797
798static void
799cifs_destroy_inodecache(void)
800{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700801 kmem_cache_destroy(cifs_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802}
803
804static int
805cifs_init_request_bufs(void)
806{
Steve French4523cc32007-04-30 20:13:06 +0000807 if (CIFSMaxBufSize < 8192) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
809 Unicode path name has to fit in any SMB/CIFS path based frames */
810 CIFSMaxBufSize = 8192;
811 } else if (CIFSMaxBufSize > 1024*127) {
812 CIFSMaxBufSize = 1024 * 127;
813 } else {
814 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
815 }
Joe Perchesb6b38f72010-04-21 03:50:45 +0000816/* cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 cifs_req_cachep = kmem_cache_create("cifs_request",
818 CIFSMaxBufSize +
819 MAX_CIFS_HDR_SIZE, 0,
Paul Mundt20c2df82007-07-20 10:11:58 +0900820 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 if (cifs_req_cachep == NULL)
822 return -ENOMEM;
823
Steve French4523cc32007-04-30 20:13:06 +0000824 if (cifs_min_rcv < 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 cifs_min_rcv = 1;
826 else if (cifs_min_rcv > 64) {
827 cifs_min_rcv = 64;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000828 cERROR(1, "cifs_min_rcv set to maximum (64)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 }
830
Matthew Dobson93d23412006-03-26 01:37:50 -0800831 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
832 cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
Steve French4523cc32007-04-30 20:13:06 +0000834 if (cifs_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 kmem_cache_destroy(cifs_req_cachep);
836 return -ENOMEM;
837 }
Steve Frenchec637e32005-12-12 20:53:18 -0800838 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 almost all handle based requests (but not write response, nor is it
840 sufficient for path based requests). A smaller size would have
Steve French50c2f752007-07-13 00:33:32 +0000841 been more efficient (compacting multiple slab items on one 4k page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 for the case in which debug was on, but this larger size allows
843 more SMBs to use small buffer alloc and is still much more
Steve French6dc0f872007-07-06 23:13:06 +0000844 efficient to alloc 1 per page off the slab compared to 17K (5page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 alloc of large cifs buffers even when page debugging is on */
846 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
Steve French6dc0f872007-07-06 23:13:06 +0000847 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +0900848 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 if (cifs_sm_req_cachep == NULL) {
850 mempool_destroy(cifs_req_poolp);
851 kmem_cache_destroy(cifs_req_cachep);
Steve French6dc0f872007-07-06 23:13:06 +0000852 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 }
854
Steve French4523cc32007-04-30 20:13:06 +0000855 if (cifs_min_small < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 cifs_min_small = 2;
857 else if (cifs_min_small > 256) {
858 cifs_min_small = 256;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000859 cFYI(1, "cifs_min_small set to maximum (256)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 }
861
Matthew Dobson93d23412006-03-26 01:37:50 -0800862 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
863 cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864
Steve French4523cc32007-04-30 20:13:06 +0000865 if (cifs_sm_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 mempool_destroy(cifs_req_poolp);
867 kmem_cache_destroy(cifs_req_cachep);
868 kmem_cache_destroy(cifs_sm_req_cachep);
869 return -ENOMEM;
870 }
871
872 return 0;
873}
874
875static void
876cifs_destroy_request_bufs(void)
877{
878 mempool_destroy(cifs_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700879 kmem_cache_destroy(cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 mempool_destroy(cifs_sm_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700881 kmem_cache_destroy(cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882}
883
884static int
885cifs_init_mids(void)
886{
887 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
Steve French26f57362007-08-30 22:09:15 +0000888 sizeof(struct mid_q_entry), 0,
889 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 if (cifs_mid_cachep == NULL)
891 return -ENOMEM;
892
Matthew Dobson93d23412006-03-26 01:37:50 -0800893 /* 3 is a reasonable minimum number of simultaneous operations */
894 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
Steve French4523cc32007-04-30 20:13:06 +0000895 if (cifs_mid_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 kmem_cache_destroy(cifs_mid_cachep);
897 return -ENOMEM;
898 }
899
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 return 0;
901}
902
903static void
904cifs_destroy_mids(void)
905{
906 mempool_destroy(cifs_mid_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700907 kmem_cache_destroy(cifs_mid_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908}
909
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910static int __init
911init_cifs(void)
912{
913 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 cifs_proc_init();
Jeff Laytone7ddee92008-11-14 13:44:38 -0500915 INIT_LIST_HEAD(&cifs_tcp_ses_list);
Steve French4ca9c192005-10-10 19:52:13 -0700916#ifdef CONFIG_CIFS_EXPERIMENTAL
917 INIT_LIST_HEAD(&GlobalDnotifyReqList);
918 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
Steve French6dc0f872007-07-06 23:13:06 +0000919#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920/*
921 * Initialize Global counters
922 */
923 atomic_set(&sesInfoAllocCount, 0);
924 atomic_set(&tconInfoAllocCount, 0);
Steve French6dc0f872007-07-06 23:13:06 +0000925 atomic_set(&tcpSesAllocCount, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 atomic_set(&tcpSesReconnectCount, 0);
927 atomic_set(&tconInfoReconnectCount, 0);
928
929 atomic_set(&bufAllocCount, 0);
Steve French4498eed52005-12-03 13:58:57 -0800930 atomic_set(&smBufAllocCount, 0);
931#ifdef CONFIG_CIFS_STATS2
932 atomic_set(&totBufAllocCount, 0);
933 atomic_set(&totSmBufAllocCount, 0);
934#endif /* CONFIG_CIFS_STATS2 */
935
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 atomic_set(&midCount, 0);
937 GlobalCurrentXid = 0;
938 GlobalTotalActiveXid = 0;
939 GlobalMaxActiveXid = 0;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530940 spin_lock_init(&cifs_tcp_ses_lock);
Jeff Layton44772882010-10-15 15:34:03 -0400941 spin_lock_init(&cifs_file_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 spin_lock_init(&GlobalMid_Lock);
943
Steve French4523cc32007-04-30 20:13:06 +0000944 if (cifs_max_pending < 2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 cifs_max_pending = 2;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000946 cFYI(1, "cifs_max_pending set to min of 2");
Steve French4523cc32007-04-30 20:13:06 +0000947 } else if (cifs_max_pending > 256) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 cifs_max_pending = 256;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000949 cFYI(1, "cifs_max_pending set to max of 256");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 }
951
Suresh Jayaramanf579cf32010-07-05 18:11:50 +0530952 rc = cifs_fscache_register();
953 if (rc)
Steve Frenchd3bf5222010-09-22 19:15:36 +0000954 goto out_clean_proc;
Suresh Jayaramanf579cf32010-07-05 18:11:50 +0530955
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 rc = cifs_init_inodecache();
Steve French45af7a02006-04-21 22:52:25 +0000957 if (rc)
Steve Frenchd3bf5222010-09-22 19:15:36 +0000958 goto out_unreg_fscache;
Steve French45af7a02006-04-21 22:52:25 +0000959
960 rc = cifs_init_mids();
961 if (rc)
962 goto out_destroy_inodecache;
963
964 rc = cifs_init_request_bufs();
965 if (rc)
966 goto out_destroy_mids;
967
968 rc = register_filesystem(&cifs_fs_type);
969 if (rc)
970 goto out_destroy_request_bufs;
Jeff Layton84a15b92007-11-03 05:02:24 +0000971#ifdef CONFIG_CIFS_UPCALL
972 rc = register_key_type(&cifs_spnego_key_type);
973 if (rc)
974 goto out_unregister_filesystem;
975#endif
Steve French45af7a02006-04-21 22:52:25 +0000976
Steve French45af7a02006-04-21 22:52:25 +0000977 return 0;
978
Jeff Layton84a15b92007-11-03 05:02:24 +0000979#ifdef CONFIG_CIFS_UPCALL
Steve Frenchd3bf5222010-09-22 19:15:36 +0000980out_unregister_filesystem:
Steve French45af7a02006-04-21 22:52:25 +0000981 unregister_filesystem(&cifs_fs_type);
Linus Torvalds1fc79952010-08-07 12:54:46 -0700982#endif
Steve Frenchd3bf5222010-09-22 19:15:36 +0000983out_destroy_request_bufs:
Steve French45af7a02006-04-21 22:52:25 +0000984 cifs_destroy_request_bufs();
Steve Frenchd3bf5222010-09-22 19:15:36 +0000985out_destroy_mids:
Steve French45af7a02006-04-21 22:52:25 +0000986 cifs_destroy_mids();
Steve Frenchd3bf5222010-09-22 19:15:36 +0000987out_destroy_inodecache:
Steve French45af7a02006-04-21 22:52:25 +0000988 cifs_destroy_inodecache();
Steve Frenchd3bf5222010-09-22 19:15:36 +0000989out_unreg_fscache:
Suresh Jayaramanf579cf32010-07-05 18:11:50 +0530990 cifs_fscache_unregister();
Steve Frenchd3bf5222010-09-22 19:15:36 +0000991out_clean_proc:
992 cifs_proc_clean();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 return rc;
994}
995
996static void __exit
997exit_cifs(void)
998{
Joe Perchesb6b38f72010-04-21 03:50:45 +0000999 cFYI(DBG2, "exit_cifs");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 cifs_proc_clean();
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301001 cifs_fscache_unregister();
Steve French61033352008-01-09 16:21:36 +00001002#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov78d31a32008-04-24 12:56:07 +04001003 cifs_dfs_release_automount_timer();
Steve French61033352008-01-09 16:21:36 +00001004#endif
Jeff Layton84a15b92007-11-03 05:02:24 +00001005#ifdef CONFIG_CIFS_UPCALL
1006 unregister_key_type(&cifs_spnego_key_type);
1007#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 unregister_filesystem(&cifs_fs_type);
1009 cifs_destroy_inodecache();
1010 cifs_destroy_mids();
1011 cifs_destroy_request_bufs();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012}
1013
1014MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
Steve French6dc0f872007-07-06 23:13:06 +00001015MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016MODULE_DESCRIPTION
Steve French63135e02007-07-17 17:34:02 +00001017 ("VFS to access servers complying with the SNIA CIFS Specification "
1018 "e.g. Samba and Windows");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019MODULE_VERSION(CIFS_VERSION);
1020module_init(init_cifs)
1021module_exit(exit_cifs)