blob: ac5915d61dca768d4f71d689c5948712e2bf012f [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include "cifsfs.h"
39#include "cifspdu.h"
40#define DECLARE_GLOBALS_HERE
41#include "cifsglob.h"
42#include "cifsproto.h"
43#include "cifs_debug.h"
44#include "cifs_fs_sb.h"
45#include <linux/mm.h>
Jeff Layton84a15b92007-11-03 05:02:24 +000046#include <linux/key-type.h>
Steve French61033352008-01-09 16:21:36 +000047#include "dns_resolve.h"
Jeff Laytone5459372007-11-03 05:11:06 +000048#include "cifs_spnego.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
50
51#ifdef CONFIG_CIFS_QUOTA
52static struct quotactl_ops cifs_quotactl_ops;
Steve French35c11fd2007-02-27 05:09:35 +000053#endif /* QUOTA */
54
Linus Torvalds1da177e2005-04-16 15:20:36 -070055int cifsFYI = 0;
56int cifsERROR = 1;
57int traceSMB = 0;
58unsigned int oplockEnabled = 1;
59unsigned int experimEnabled = 0;
60unsigned int linuxExtEnabled = 1;
61unsigned int lookupCacheEnabled = 1;
62unsigned int multiuser_mount = 0;
Steve French39798772006-05-31 22:40:51 +000063unsigned int extended_security = CIFSSEC_DEF;
64/* unsigned int ntlmv2_support = 0; */
Linus Torvalds1da177e2005-04-16 15:20:36 -070065unsigned int sign_CIFS_PDUs = 1;
Steve French6dc0f872007-07-06 23:13:06 +000066extern struct task_struct *oplockThread; /* remove sparse warning */
67struct task_struct *oplockThread = NULL;
Steve French99ee4db2007-02-27 05:35:17 +000068/* extern struct task_struct * dnotifyThread; remove sparse warning */
Steve French6dc0f872007-07-06 23:13:06 +000069static struct task_struct *dnotifyThread = NULL;
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -080070static const struct super_operations cifs_super_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070071unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
72module_param(CIFSMaxBufSize, int, 0);
Steve French63135e02007-07-17 17:34:02 +000073MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
74 "Default: 16384 Range: 8192 to 130048");
Linus Torvalds1da177e2005-04-16 15:20:36 -070075unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
76module_param(cifs_min_rcv, int, 0);
Steve French63135e02007-07-17 17:34:02 +000077MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
78 "1 to 64");
Linus Torvalds1da177e2005-04-16 15:20:36 -070079unsigned int cifs_min_small = 30;
80module_param(cifs_min_small, int, 0);
Steve French63135e02007-07-17 17:34:02 +000081MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
82 "Range: 2 to 256");
Linus Torvalds1da177e2005-04-16 15:20:36 -070083unsigned int cifs_max_pending = CIFS_MAX_REQ;
84module_param(cifs_max_pending, int, 0);
Steve French63135e02007-07-17 17:34:02 +000085MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
86 "Default: 50 Range: 2 to 256");
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
Linus Torvalds1da177e2005-04-16 15:20:36 -070088extern mempool_t *cifs_sm_req_poolp;
89extern mempool_t *cifs_req_poolp;
90extern mempool_t *cifs_mid_poolp;
91
Christoph Lametere18b8902006-12-06 20:33:20 -080092extern struct kmem_cache *cifs_oplock_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
94static int
95cifs_read_super(struct super_block *sb, void *data,
96 const char *devname, int silent)
97{
98 struct inode *inode;
99 struct cifs_sb_info *cifs_sb;
100 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +0000101
Steve French1b2b2122007-02-17 04:30:54 +0000102 /* BB should we make this contingent on mount parm? */
103 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
Steve French790fe572007-07-07 19:25:05 +0000104 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 cifs_sb = CIFS_SB(sb);
Steve French4523cc32007-04-30 20:13:06 +0000106 if (cifs_sb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108
Igor Mammedove6ab1582008-01-11 01:49:48 +0000109#ifdef CONFIG_CIFS_DFS_UPCALL
110 /* copy mount params to sb for use in submounts */
111 /* BB: should we move this after the mount so we
112 * do not have to do the copy on failed mounts?
113 * BB: May be it is better to do simple copy before
114 * complex operation (mount), and in case of fail
115 * just exit instead of doing mount and attempting
116 * undo it if this copy fails?*/
Steve French79ee9a82008-06-10 21:37:02 +0000117 if (data) {
118 int len = strlen(data);
119 cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
120 if (cifs_sb->mountdata == NULL) {
121 kfree(sb->s_fs_info);
122 sb->s_fs_info = NULL;
123 return -ENOMEM;
124 }
125 strncpy(cifs_sb->mountdata, data, len + 1);
126 cifs_sb->mountdata[len] = '\0';
Igor Mammedove6ab1582008-01-11 01:49:48 +0000127 }
Igor Mammedove6ab1582008-01-11 01:49:48 +0000128#endif
129
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 rc = cifs_mount(sb, cifs_sb, data, devname);
131
132 if (rc) {
133 if (!silent)
134 cERROR(1,
135 ("cifs_mount failed w/return code = %d", rc));
136 goto out_mount_failed;
137 }
138
139 sb->s_magic = CIFS_MAGIC_NUMBER;
140 sb->s_op = &cifs_super_ops;
Steve French4523cc32007-04-30 20:13:06 +0000141/* if (cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
Steve French790fe572007-07-07 19:25:05 +0000142 sb->s_blocksize =
143 cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144#ifdef CONFIG_CIFS_QUOTA
145 sb->s_qcop = &cifs_quotactl_ops;
146#endif
147 sb->s_blocksize = CIFS_MAX_MSGSIZE;
148 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
David Howellsce634ab2008-02-07 00:15:33 -0800149 inode = cifs_iget(sb, ROOT_I);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150
David Howellsce634ab2008-02-07 00:15:33 -0800151 if (IS_ERR(inode)) {
152 rc = PTR_ERR(inode);
153 inode = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 goto out_no_root;
155 }
156
157 sb->s_root = d_alloc_root(inode);
158
159 if (!sb->s_root) {
160 rc = -ENOMEM;
161 goto out_no_root;
162 }
Steve French50c2f752007-07-13 00:33:32 +0000163
Steve French7521a3c2007-07-11 18:30:34 +0000164#ifdef CONFIG_CIFS_EXPERIMENTAL
165 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
166 cFYI(1, ("export ops supported"));
167 sb->s_export_op = &cifs_export_ops;
168 }
169#endif /* EXPERIMENTAL */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
171 return 0;
172
173out_no_root:
174 cERROR(1, ("cifs_read_super: get root inode failed"));
175 if (inode)
176 iput(inode);
Steve French54b46022008-08-11 22:31:40 +0000177
Steve French2c731af2008-08-11 22:28:53 +0000178 cifs_umount(sb, cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
180out_mount_failed:
Steve French4523cc32007-04-30 20:13:06 +0000181 if (cifs_sb) {
Igor Mammedove6ab1582008-01-11 01:49:48 +0000182#ifdef CONFIG_CIFS_DFS_UPCALL
183 if (cifs_sb->mountdata) {
184 kfree(cifs_sb->mountdata);
185 cifs_sb->mountdata = NULL;
186 }
187#endif
Steve French4523cc32007-04-30 20:13:06 +0000188 if (cifs_sb->local_nls)
Steve French50c2f752007-07-13 00:33:32 +0000189 unload_nls(cifs_sb->local_nls);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 kfree(cifs_sb);
191 }
192 return rc;
193}
194
195static void
196cifs_put_super(struct super_block *sb)
197{
198 int rc = 0;
199 struct cifs_sb_info *cifs_sb;
200
201 cFYI(1, ("In cifs_put_super"));
202 cifs_sb = CIFS_SB(sb);
Steve French4523cc32007-04-30 20:13:06 +0000203 if (cifs_sb == NULL) {
Steve French790fe572007-07-07 19:25:05 +0000204 cFYI(1, ("Empty cifs superblock info passed to unmount"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 return;
206 }
Steve French790fe572007-07-07 19:25:05 +0000207 rc = cifs_umount(sb, cifs_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +0000208 if (rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 cERROR(1, ("cifs_umount failed with return code %d", rc));
Igor Mammedove6ab1582008-01-11 01:49:48 +0000210#ifdef CONFIG_CIFS_DFS_UPCALL
211 if (cifs_sb->mountdata) {
212 kfree(cifs_sb->mountdata);
213 cifs_sb->mountdata = NULL;
214 }
215#endif
216
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 unload_nls(cifs_sb->local_nls);
218 kfree(cifs_sb);
219 return;
220}
221
222static int
David Howells726c3342006-06-23 02:02:58 -0700223cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224{
David Howells726c3342006-06-23 02:02:58 -0700225 struct super_block *sb = dentry->d_sb;
Steve French39da9842008-04-28 04:04:34 +0000226 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
227 struct cifsTconInfo *tcon = cifs_sb->tcon;
Steve Frenchc81156d2005-04-28 22:41:07 -0700228 int rc = -EOPNOTSUPP;
Steve French39da9842008-04-28 04:04:34 +0000229 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
231 xid = GetXid();
232
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 buf->f_type = CIFS_MAGIC_NUMBER;
234
Steve French39da9842008-04-28 04:04:34 +0000235 /*
236 * PATH_MAX may be too long - it would presumably be total path,
237 * but note that some servers (includinng Samba 3) have a shorter
238 * maximum path.
239 *
240 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
241 */
242 buf->f_namelen = PATH_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 buf->f_files = 0; /* undefined */
244 buf->f_ffree = 0; /* unlimited */
245
Steve French39da9842008-04-28 04:04:34 +0000246 /*
247 * We could add a second check for a QFS Unix capability bit
248 */
249 if ((tcon->ses->capabilities & CAP_UNIX) &&
250 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
251 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
Steve French39da9842008-04-28 04:04:34 +0000253 /*
254 * Only need to call the old QFSInfo if failed on newer one,
255 * e.g. by OS/2.
256 **/
257 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
258 rc = CIFSSMBQFSInfo(xid, tcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Steve French39da9842008-04-28 04:04:34 +0000260 /*
261 * Some old Windows servers also do not support level 103, retry with
262 * older level one if old server failed the previous call or we
263 * bypassed it because we detected that this was an older LANMAN sess
264 */
Steve French4523cc32007-04-30 20:13:06 +0000265 if (rc)
Steve French39da9842008-04-28 04:04:34 +0000266 rc = SMBOldQFSInfo(xid, tcon, buf);
267
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 FreeXid(xid);
Steve French39da9842008-04-28 04:04:34 +0000269 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270}
271
Al Viroe6305c42008-07-15 21:03:57 -0400272static int cifs_permission(struct inode *inode, int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273{
274 struct cifs_sb_info *cifs_sb;
275
276 cifs_sb = CIFS_SB(inode->i_sb);
277
Miklos Szeredif696a362008-07-31 13:41:58 +0200278 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
279 if ((mask & MAY_EXEC) && !execute_ok(inode))
280 return -EACCES;
281 else
282 return 0;
283 } else /* file mode might have been restricted at mount time
Steve French50c2f752007-07-13 00:33:32 +0000284 on the client (above and beyond ACL on servers) for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 servers which do not support setting and viewing mode bits,
Steve French50c2f752007-07-13 00:33:32 +0000286 so allowing client to check permissions is useful */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 return generic_permission(inode, mask, NULL);
288}
289
Christoph Lametere18b8902006-12-06 20:33:20 -0800290static struct kmem_cache *cifs_inode_cachep;
291static struct kmem_cache *cifs_req_cachep;
292static struct kmem_cache *cifs_mid_cachep;
293struct kmem_cache *cifs_oplock_cachep;
294static struct kmem_cache *cifs_sm_req_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295mempool_t *cifs_sm_req_poolp;
296mempool_t *cifs_req_poolp;
297mempool_t *cifs_mid_poolp;
298
299static struct inode *
300cifs_alloc_inode(struct super_block *sb)
301{
302 struct cifsInodeInfo *cifs_inode;
Christoph Lametere94b1762006-12-06 20:33:17 -0800303 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 if (!cifs_inode)
305 return NULL;
306 cifs_inode->cifsAttrs = 0x20; /* default */
307 atomic_set(&cifs_inode->inUse, 0);
308 cifs_inode->time = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +0000309 cifs_inode->write_behind_rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 /* Until the file is open and we have gotten oplock
311 info back from the server, can not assume caching of
312 file data or metadata */
Steve French4b18f2a2008-04-29 00:06:05 +0000313 cifs_inode->clientCanCacheRead = false;
314 cifs_inode->clientCanCacheAll = false;
Jeff Layton9a8165f2008-10-17 21:03:20 -0400315 cifs_inode->delete_pending = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
Steve French50c2f752007-07-13 00:33:32 +0000317
Steve French1b2b2122007-02-17 04:30:54 +0000318 /* Can not set i_flags here - they get immediately overwritten
319 to zero by the VFS */
320/* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 INIT_LIST_HEAD(&cifs_inode->openFileList);
322 return &cifs_inode->vfs_inode;
323}
324
325static void
326cifs_destroy_inode(struct inode *inode)
327{
328 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
329}
330
331/*
332 * cifs_show_options() is for displaying mount options in /proc/mounts.
333 * Not all settable options are displayed but most of the important
334 * ones are.
335 */
336static int
337cifs_show_options(struct seq_file *s, struct vfsmount *m)
338{
339 struct cifs_sb_info *cifs_sb;
340
341 cifs_sb = CIFS_SB(m->mnt_sb);
342
343 if (cifs_sb) {
344 if (cifs_sb->tcon) {
Steve French004c46b2007-02-17 04:34:13 +0000345/* BB add prepath to mount options displayed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
347 if (cifs_sb->tcon->ses) {
348 if (cifs_sb->tcon->ses->userName)
349 seq_printf(s, ",username=%s",
350 cifs_sb->tcon->ses->userName);
Steve French4523cc32007-04-30 20:13:06 +0000351 if (cifs_sb->tcon->ses->domainName)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 seq_printf(s, ",domain=%s",
353 cifs_sb->tcon->ses->domainName);
354 }
Steve Frenchd5d18502007-10-17 21:31:52 +0000355 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) ||
356 !(cifs_sb->tcon->unix_ext))
357 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
358 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) ||
359 !(cifs_sb->tcon->unix_ext))
360 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
Steve French2b280fa2008-05-17 03:12:45 +0000361 if (!cifs_sb->tcon->unix_ext) {
362 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
363 cifs_sb->mnt_file_mode,
364 cifs_sb->mnt_dir_mode);
365 }
366 if (cifs_sb->tcon->seal)
367 seq_printf(s, ",seal");
Steve French89562b72008-05-19 22:26:42 +0000368 if (cifs_sb->tcon->nocase)
Steve French2b280fa2008-05-17 03:12:45 +0000369 seq_printf(s, ",nocase");
Steve French89562b72008-05-19 22:26:42 +0000370 if (cifs_sb->tcon->retry)
371 seq_printf(s, ",hard");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 }
Steve French4523cc32007-04-30 20:13:06 +0000373 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
374 seq_printf(s, ",posixpaths");
Steve French2b280fa2008-05-17 03:12:45 +0000375 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
376 seq_printf(s, ",setuids");
377 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
378 seq_printf(s, ",serverino");
379 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
380 seq_printf(s, ",directio");
381 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
382 seq_printf(s, ",nouser_xattr");
383 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
384 seq_printf(s, ",mapchars");
385 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
386 seq_printf(s, ",sfu");
387 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
388 seq_printf(s, ",nobrl");
389 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
390 seq_printf(s, ",cifsacl");
391 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
392 seq_printf(s, ",dynperm");
393 if (m->mnt_sb->s_flags & MS_POSIXACL)
394 seq_printf(s, ",acl");
395
Steve French50c2f752007-07-13 00:33:32 +0000396 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
397 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 }
399 return 0;
400}
401
402#ifdef CONFIG_CIFS_QUOTA
Steve French50c2f752007-07-13 00:33:32 +0000403int cifs_xquota_set(struct super_block *sb, int quota_type, qid_t qid,
404 struct fs_disk_quota *pdquota)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405{
406 int xid;
407 int rc = 0;
408 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
409 struct cifsTconInfo *pTcon;
Steve French50c2f752007-07-13 00:33:32 +0000410
Steve French4523cc32007-04-30 20:13:06 +0000411 if (cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 pTcon = cifs_sb->tcon;
413 else
414 return -EIO;
415
416
417 xid = GetXid();
Steve French4523cc32007-04-30 20:13:06 +0000418 if (pTcon) {
Steve French50c2f752007-07-13 00:33:32 +0000419 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 } else {
Cyrill Gorcunov95ba7362007-08-24 00:23:36 +0000421 rc = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 }
423
424 FreeXid(xid);
425 return rc;
426}
427
Steve French50c2f752007-07-13 00:33:32 +0000428int cifs_xquota_get(struct super_block *sb, int quota_type, qid_t qid,
429 struct fs_disk_quota *pdquota)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430{
431 int xid;
432 int rc = 0;
433 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
434 struct cifsTconInfo *pTcon;
435
Steve French4523cc32007-04-30 20:13:06 +0000436 if (cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 pTcon = cifs_sb->tcon;
438 else
439 return -EIO;
440
441 xid = GetXid();
Steve French4523cc32007-04-30 20:13:06 +0000442 if (pTcon) {
Steve French50c2f752007-07-13 00:33:32 +0000443 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 } else {
445 rc = -EIO;
446 }
447
448 FreeXid(xid);
449 return rc;
450}
451
Steve French50c2f752007-07-13 00:33:32 +0000452int cifs_xstate_set(struct super_block *sb, unsigned int flags, int operation)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453{
Steve French50c2f752007-07-13 00:33:32 +0000454 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 int rc = 0;
456 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
457 struct cifsTconInfo *pTcon;
458
Steve French4523cc32007-04-30 20:13:06 +0000459 if (cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 pTcon = cifs_sb->tcon;
461 else
462 return -EIO;
463
464 xid = GetXid();
Steve French4523cc32007-04-30 20:13:06 +0000465 if (pTcon) {
Steve French50c2f752007-07-13 00:33:32 +0000466 cFYI(1, ("flags: 0x%x operation: 0x%x", flags, operation));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 } else {
468 rc = -EIO;
469 }
470
471 FreeXid(xid);
472 return rc;
473}
474
Steve French50c2f752007-07-13 00:33:32 +0000475int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476{
477 int xid;
478 int rc = 0;
479 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
480 struct cifsTconInfo *pTcon;
481
Steve French4523cc32007-04-30 20:13:06 +0000482 if (cifs_sb) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 pTcon = cifs_sb->tcon;
484 } else {
485 return -EIO;
486 }
487 xid = GetXid();
Steve French4523cc32007-04-30 20:13:06 +0000488 if (pTcon) {
Steve French50c2f752007-07-13 00:33:32 +0000489 cFYI(1, ("pqstats %p", qstats));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 } else {
491 rc = -EIO;
492 }
493
494 FreeXid(xid);
495 return rc;
496}
497
498static struct quotactl_ops cifs_quotactl_ops = {
499 .set_xquota = cifs_xquota_set,
Roel Kluin6f7e8f32008-02-12 20:38:10 +0000500 .get_xquota = cifs_xquota_get,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 .set_xstate = cifs_xstate_set,
502 .get_xstate = cifs_xstate_get,
503};
504#endif
505
Al Viro42faad92008-04-24 07:21:56 -0400506static void cifs_umount_begin(struct super_block *sb)
Steve French68058e72005-10-10 10:34:22 -0700507{
Al Viro42faad92008-04-24 07:21:56 -0400508 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French50c2f752007-07-13 00:33:32 +0000509 struct cifsTconInfo *tcon;
Steve French68058e72005-10-10 10:34:22 -0700510
Steve French4523cc32007-04-30 20:13:06 +0000511 if (cifs_sb == NULL)
Steve French9e2e85f2005-10-10 14:28:38 -0700512 return;
513
514 tcon = cifs_sb->tcon;
Steve French4523cc32007-04-30 20:13:06 +0000515 if (tcon == NULL)
Steve French9e2e85f2005-10-10 14:28:38 -0700516 return;
Steve French5e1253b2005-10-10 14:06:37 -0700517 down(&tcon->tconSem);
518 if (atomic_read(&tcon->useCount) == 1)
519 tcon->tidStatus = CifsExiting;
520 up(&tcon->tconSem);
521
Steve French3a5ff612006-07-14 22:37:11 +0000522 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
Steve French7b7abfe2005-11-09 15:21:09 -0800523 /* cancel_notify_requests(tcon); */
Steve French50c2f752007-07-13 00:33:32 +0000524 if (tcon->ses && tcon->ses->server) {
525 cFYI(1, ("wake up tasks now - umount begin not complete"));
Steve French9e2e85f2005-10-10 14:28:38 -0700526 wake_up_all(&tcon->ses->server->request_q);
Steve French6ab16d22005-11-29 20:55:11 -0800527 wake_up_all(&tcon->ses->server->response_q);
528 msleep(1); /* yield */
529 /* we have to kick the requests once more */
530 wake_up_all(&tcon->ses->server->response_q);
531 msleep(1);
Steve French5e1253b2005-10-10 14:06:37 -0700532 }
533/* BB FIXME - finish add checks for tidStatus BB */
Steve French68058e72005-10-10 10:34:22 -0700534
535 return;
536}
Steve French68058e72005-10-10 10:34:22 -0700537
Steve Frenchbf97d282006-09-28 21:34:06 +0000538#ifdef CONFIG_CIFS_STATS2
539static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
540{
541 /* BB FIXME */
542 return 0;
543}
544#endif
545
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546static int cifs_remount(struct super_block *sb, int *flags, char *data)
547{
548 *flags |= MS_NODIRATIME;
549 return 0;
550}
551
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800552static const struct super_operations cifs_super_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 .put_super = cifs_put_super,
554 .statfs = cifs_statfs,
555 .alloc_inode = cifs_alloc_inode,
556 .destroy_inode = cifs_destroy_inode,
Steve French50c2f752007-07-13 00:33:32 +0000557/* .drop_inode = generic_delete_inode,
558 .delete_inode = cifs_delete_inode, */ /* Do not need above two
559 functions unless later we add lazy close of inodes or unless the
560 kernel forgets to call us with the same number of releases (closes)
561 as opens */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 .show_options = cifs_show_options,
Steve French7b7abfe2005-11-09 15:21:09 -0800563 .umount_begin = cifs_umount_begin,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 .remount_fs = cifs_remount,
Steve Frenchbf97d282006-09-28 21:34:06 +0000565#ifdef CONFIG_CIFS_STATS2
Steve Frenchf46d3e12006-09-30 01:08:55 +0000566 .show_stats = cifs_show_stats,
Steve Frenchbf97d282006-09-28 21:34:06 +0000567#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568};
569
David Howells454e2392006-06-23 02:02:57 -0700570static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571cifs_get_sb(struct file_system_type *fs_type,
David Howells454e2392006-06-23 02:02:57 -0700572 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573{
574 int rc;
575 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
576
577 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
578
579 if (IS_ERR(sb))
David Howells454e2392006-06-23 02:02:57 -0700580 return PTR_ERR(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
582 sb->s_flags = flags;
583
Theodore Ts'o9b04c992006-03-24 03:15:10 -0800584 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 if (rc) {
586 up_write(&sb->s_umount);
587 deactivate_super(sb);
David Howells454e2392006-06-23 02:02:57 -0700588 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 }
590 sb->s_flags |= MS_ACTIVE;
David Howells454e2392006-06-23 02:02:57 -0700591 return simple_set_mnt(mnt, sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592}
593
Badari Pulavarty027445c2006-09-30 23:28:46 -0700594static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
595 unsigned long nr_segs, loff_t pos)
Steve French87c89dd2005-11-17 17:03:00 -0800596{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800597 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
Steve French87c89dd2005-11-17 17:03:00 -0800598 ssize_t written;
599
Badari Pulavarty027445c2006-09-30 23:28:46 -0700600 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
Steve French87c89dd2005-11-17 17:03:00 -0800601 if (!CIFS_I(inode)->clientCanCacheAll)
602 filemap_fdatawrite(inode->i_mapping);
603 return written;
604}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605
Steve Frenchc32a0b62006-01-12 14:41:28 -0800606static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
607{
608 /* origin == SEEK_END => we must revalidate the cached file length */
Steve French0889a942006-09-23 22:11:07 +0000609 if (origin == SEEK_END) {
Steve French030e9d82007-02-01 04:27:59 +0000610 int retval;
611
612 /* some applications poll for the file length in this strange
613 way so we must seek to end on non-oplocked files by
614 setting the revalidate time to zero */
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000615 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
Steve French030e9d82007-02-01 04:27:59 +0000616
617 retval = cifs_revalidate(file->f_path.dentry);
Steve Frenchc32a0b62006-01-12 14:41:28 -0800618 if (retval < 0)
619 return (loff_t)retval;
620 }
Andi Kleen9465efc2008-06-27 11:05:24 +0200621 return generic_file_llseek_unlocked(file, offset, origin);
Steve Frenchc32a0b62006-01-12 14:41:28 -0800622}
623
Steve French84210e92008-10-23 04:42:37 +0000624#ifdef CONFIG_CIFS_EXPERIMENTAL
625static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
626{
627 /* note that this is called by vfs setlease with the BKL held
628 although I doubt that BKL is needed here in cifs */
629 struct inode *inode = file->f_path.dentry->d_inode;
630
631 if (!(S_ISREG(inode->i_mode)))
632 return -EINVAL;
633
634 /* check if file is oplocked */
635 if (((arg == F_RDLCK) &&
636 (CIFS_I(inode)->clientCanCacheRead)) ||
637 ((arg == F_WRLCK) &&
638 (CIFS_I(inode)->clientCanCacheAll)))
639 return generic_setlease(file, arg, lease);
640 else if (CIFS_SB(inode->i_sb)->tcon->local_lease &&
641 !CIFS_I(inode)->clientCanCacheRead)
642 /* If the server claims to support oplock on this
643 file, then we still need to check oplock even
644 if the local_lease mount option is set, but there
645 are servers which do not support oplock for which
646 this mount option may be useful if the user
647 knows that the file won't be changed on the server
648 by anyone else */
649 return generic_setlease(file, arg, lease);
650 else
651 return -EAGAIN;
652}
653#endif
654
Igor Mammedove6ab1582008-01-11 01:49:48 +0000655struct file_system_type cifs_fs_type = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 .owner = THIS_MODULE,
657 .name = "cifs",
658 .get_sb = cifs_get_sb,
659 .kill_sb = kill_anon_super,
660 /* .fs_flags */
661};
Arjan van de Ven754661f2007-02-12 00:55:38 -0800662const struct inode_operations cifs_dir_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 .create = cifs_create,
664 .lookup = cifs_lookup,
665 .getattr = cifs_getattr,
666 .unlink = cifs_unlink,
667 .link = cifs_hardlink,
668 .mkdir = cifs_mkdir,
669 .rmdir = cifs_rmdir,
670 .rename = cifs_rename,
671 .permission = cifs_permission,
672/* revalidate:cifs_revalidate, */
673 .setattr = cifs_setattr,
674 .symlink = cifs_symlink,
675 .mknod = cifs_mknod,
676#ifdef CONFIG_CIFS_XATTR
677 .setxattr = cifs_setxattr,
678 .getxattr = cifs_getxattr,
679 .listxattr = cifs_listxattr,
680 .removexattr = cifs_removexattr,
681#endif
682};
683
Arjan van de Ven754661f2007-02-12 00:55:38 -0800684const struct inode_operations cifs_file_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685/* revalidate:cifs_revalidate, */
686 .setattr = cifs_setattr,
687 .getattr = cifs_getattr, /* do we need this anymore? */
688 .rename = cifs_rename,
689 .permission = cifs_permission,
690#ifdef CONFIG_CIFS_XATTR
691 .setxattr = cifs_setxattr,
692 .getxattr = cifs_getxattr,
693 .listxattr = cifs_listxattr,
694 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000695#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696};
697
Arjan van de Ven754661f2007-02-12 00:55:38 -0800698const struct inode_operations cifs_symlink_inode_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000699 .readlink = generic_readlink,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 .follow_link = cifs_follow_link,
701 .put_link = cifs_put_link,
702 .permission = cifs_permission,
703 /* BB add the following two eventually */
704 /* revalidate: cifs_revalidate,
705 setattr: cifs_notify_change, *//* BB do we need notify change */
706#ifdef CONFIG_CIFS_XATTR
707 .setxattr = cifs_setxattr,
708 .getxattr = cifs_getxattr,
709 .listxattr = cifs_listxattr,
710 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000711#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712};
713
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800714const struct file_operations cifs_file_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800715 .read = do_sync_read,
716 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800717 .aio_read = generic_file_aio_read,
718 .aio_write = cifs_file_aio_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 .open = cifs_open,
720 .release = cifs_close,
721 .lock = cifs_lock,
722 .fsync = cifs_fsync,
723 .flush = cifs_flush,
724 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200725 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800726 .llseek = cifs_llseek,
Steve Frenchc67593a2005-04-28 22:41:04 -0700727#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000728 .unlocked_ioctl = cifs_ioctl,
Steve Frenchc67593a2005-04-28 22:41:04 -0700729#endif /* CONFIG_CIFS_POSIX */
730
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731#ifdef CONFIG_CIFS_EXPERIMENTAL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 .dir_notify = cifs_dir_notify,
Steve French84210e92008-10-23 04:42:37 +0000733 .setlease = cifs_setlease,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734#endif /* CONFIG_CIFS_EXPERIMENTAL */
735};
736
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800737const struct file_operations cifs_file_direct_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000738 /* no mmap, no aio, no readv -
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 BB reevaluate whether they can be done with directio, no cache */
740 .read = cifs_user_read,
741 .write = cifs_user_write,
742 .open = cifs_open,
743 .release = cifs_close,
744 .lock = cifs_lock,
745 .fsync = cifs_fsync,
746 .flush = cifs_flush,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200747 .splice_read = generic_file_splice_read,
Steve Frenchc67593a2005-04-28 22:41:04 -0700748#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000749 .unlocked_ioctl = cifs_ioctl,
Steve Frenchc67593a2005-04-28 22:41:04 -0700750#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800751 .llseek = cifs_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752#ifdef CONFIG_CIFS_EXPERIMENTAL
753 .dir_notify = cifs_dir_notify,
Steve French84210e92008-10-23 04:42:37 +0000754 .setlease = cifs_setlease,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755#endif /* CONFIG_CIFS_EXPERIMENTAL */
756};
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800757const struct file_operations cifs_file_nobrl_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800758 .read = do_sync_read,
759 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800760 .aio_read = generic_file_aio_read,
761 .aio_write = cifs_file_aio_write,
762 .open = cifs_open,
763 .release = cifs_close,
764 .fsync = cifs_fsync,
765 .flush = cifs_flush,
766 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200767 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800768 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800769#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000770 .unlocked_ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800771#endif /* CONFIG_CIFS_POSIX */
772
773#ifdef CONFIG_CIFS_EXPERIMENTAL
Steve French87c89dd2005-11-17 17:03:00 -0800774 .dir_notify = cifs_dir_notify,
Steve French84210e92008-10-23 04:42:37 +0000775 .setlease = cifs_setlease,
Steve French8b94bcb2005-11-11 11:41:00 -0800776#endif /* CONFIG_CIFS_EXPERIMENTAL */
777};
778
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800779const struct file_operations cifs_file_direct_nobrl_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000780 /* no mmap, no aio, no readv -
Steve French87c89dd2005-11-17 17:03:00 -0800781 BB reevaluate whether they can be done with directio, no cache */
782 .read = cifs_user_read,
783 .write = cifs_user_write,
784 .open = cifs_open,
785 .release = cifs_close,
786 .fsync = cifs_fsync,
787 .flush = cifs_flush,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200788 .splice_read = generic_file_splice_read,
Steve French8b94bcb2005-11-11 11:41:00 -0800789#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000790 .unlocked_ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800791#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800792 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800793#ifdef CONFIG_CIFS_EXPERIMENTAL
Steve French87c89dd2005-11-17 17:03:00 -0800794 .dir_notify = cifs_dir_notify,
Steve French84210e92008-10-23 04:42:37 +0000795 .setlease = cifs_setlease,
Steve French8b94bcb2005-11-11 11:41:00 -0800796#endif /* CONFIG_CIFS_EXPERIMENTAL */
797};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800799const struct file_operations cifs_dir_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 .readdir = cifs_readdir,
801 .release = cifs_closedir,
802 .read = generic_read_dir,
803#ifdef CONFIG_CIFS_EXPERIMENTAL
804 .dir_notify = cifs_dir_notify,
805#endif /* CONFIG_CIFS_EXPERIMENTAL */
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000806 .unlocked_ioctl = cifs_ioctl,
Christoph Hellwig3222a3e2008-09-03 21:53:01 +0200807 .llseek = generic_file_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808};
809
810static void
Alexey Dobriyan51cc5062008-07-25 19:45:34 -0700811cifs_init_once(void *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812{
813 struct cifsInodeInfo *cifsi = inode;
814
Christoph Lametera35afb82007-05-16 22:10:57 -0700815 inode_init_once(&cifsi->vfs_inode);
816 INIT_LIST_HEAD(&cifsi->lockList);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817}
818
819static int
820cifs_init_inodecache(void)
821{
822 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
Steve French26f57362007-08-30 22:09:15 +0000823 sizeof(struct cifsInodeInfo),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800824 0, (SLAB_RECLAIM_ACCOUNT|
825 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +0900826 cifs_init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 if (cifs_inode_cachep == NULL)
828 return -ENOMEM;
829
830 return 0;
831}
832
833static void
834cifs_destroy_inodecache(void)
835{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700836 kmem_cache_destroy(cifs_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837}
838
839static int
840cifs_init_request_bufs(void)
841{
Steve French4523cc32007-04-30 20:13:06 +0000842 if (CIFSMaxBufSize < 8192) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
844 Unicode path name has to fit in any SMB/CIFS path based frames */
845 CIFSMaxBufSize = 8192;
846 } else if (CIFSMaxBufSize > 1024*127) {
847 CIFSMaxBufSize = 1024 * 127;
848 } else {
849 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
850 }
851/* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
852 cifs_req_cachep = kmem_cache_create("cifs_request",
853 CIFSMaxBufSize +
854 MAX_CIFS_HDR_SIZE, 0,
Paul Mundt20c2df82007-07-20 10:11:58 +0900855 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 if (cifs_req_cachep == NULL)
857 return -ENOMEM;
858
Steve French4523cc32007-04-30 20:13:06 +0000859 if (cifs_min_rcv < 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 cifs_min_rcv = 1;
861 else if (cifs_min_rcv > 64) {
862 cifs_min_rcv = 64;
Steve French50c2f752007-07-13 00:33:32 +0000863 cERROR(1, ("cifs_min_rcv set to maximum (64)"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 }
865
Matthew Dobson93d23412006-03-26 01:37:50 -0800866 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
867 cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868
Steve French4523cc32007-04-30 20:13:06 +0000869 if (cifs_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 kmem_cache_destroy(cifs_req_cachep);
871 return -ENOMEM;
872 }
Steve Frenchec637e32005-12-12 20:53:18 -0800873 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 almost all handle based requests (but not write response, nor is it
875 sufficient for path based requests). A smaller size would have
Steve French50c2f752007-07-13 00:33:32 +0000876 been more efficient (compacting multiple slab items on one 4k page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 for the case in which debug was on, but this larger size allows
878 more SMBs to use small buffer alloc and is still much more
Steve French6dc0f872007-07-06 23:13:06 +0000879 efficient to alloc 1 per page off the slab compared to 17K (5page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 alloc of large cifs buffers even when page debugging is on */
881 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
Steve French6dc0f872007-07-06 23:13:06 +0000882 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +0900883 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 if (cifs_sm_req_cachep == NULL) {
885 mempool_destroy(cifs_req_poolp);
886 kmem_cache_destroy(cifs_req_cachep);
Steve French6dc0f872007-07-06 23:13:06 +0000887 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 }
889
Steve French4523cc32007-04-30 20:13:06 +0000890 if (cifs_min_small < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 cifs_min_small = 2;
892 else if (cifs_min_small > 256) {
893 cifs_min_small = 256;
Steve French6dc0f872007-07-06 23:13:06 +0000894 cFYI(1, ("cifs_min_small set to maximum (256)"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 }
896
Matthew Dobson93d23412006-03-26 01:37:50 -0800897 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
898 cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899
Steve French4523cc32007-04-30 20:13:06 +0000900 if (cifs_sm_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 mempool_destroy(cifs_req_poolp);
902 kmem_cache_destroy(cifs_req_cachep);
903 kmem_cache_destroy(cifs_sm_req_cachep);
904 return -ENOMEM;
905 }
906
907 return 0;
908}
909
910static void
911cifs_destroy_request_bufs(void)
912{
913 mempool_destroy(cifs_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700914 kmem_cache_destroy(cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 mempool_destroy(cifs_sm_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700916 kmem_cache_destroy(cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917}
918
919static int
920cifs_init_mids(void)
921{
922 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
Steve French26f57362007-08-30 22:09:15 +0000923 sizeof(struct mid_q_entry), 0,
924 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 if (cifs_mid_cachep == NULL)
926 return -ENOMEM;
927
Matthew Dobson93d23412006-03-26 01:37:50 -0800928 /* 3 is a reasonable minimum number of simultaneous operations */
929 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
Steve French4523cc32007-04-30 20:13:06 +0000930 if (cifs_mid_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 kmem_cache_destroy(cifs_mid_cachep);
932 return -ENOMEM;
933 }
934
935 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
Steve French26f57362007-08-30 22:09:15 +0000936 sizeof(struct oplock_q_entry), 0,
937 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 if (cifs_oplock_cachep == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 mempool_destroy(cifs_mid_poolp);
Akinobu Mitae6985c72007-06-04 16:14:59 +0000940 kmem_cache_destroy(cifs_mid_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 return -ENOMEM;
942 }
943
944 return 0;
945}
946
947static void
948cifs_destroy_mids(void)
949{
950 mempool_destroy(cifs_mid_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700951 kmem_cache_destroy(cifs_mid_cachep);
952 kmem_cache_destroy(cifs_oplock_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953}
954
Steve French50c2f752007-07-13 00:33:32 +0000955static int cifs_oplock_thread(void *dummyarg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956{
Steve French6dc0f872007-07-06 23:13:06 +0000957 struct oplock_q_entry *oplock_item;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 struct cifsTconInfo *pTcon;
Steve French6dc0f872007-07-06 23:13:06 +0000959 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 __u16 netfid;
Jeff Laytoncea21802007-11-20 23:19:03 +0000961 int rc, waitrc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700963 set_freezable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 do {
Steve French6dc0f872007-07-06 23:13:06 +0000965 if (try_to_freeze())
Steve Frenchede13272005-08-30 20:10:14 -0700966 continue;
Steve French50c2f752007-07-13 00:33:32 +0000967
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 spin_lock(&GlobalMid_Lock);
Steve French4523cc32007-04-30 20:13:06 +0000969 if (list_empty(&GlobalOplock_Q)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 spin_unlock(&GlobalMid_Lock);
971 set_current_state(TASK_INTERRUPTIBLE);
972 schedule_timeout(39*HZ);
973 } else {
Steve French6dc0f872007-07-06 23:13:06 +0000974 oplock_item = list_entry(GlobalOplock_Q.next,
Steve Frenchad8b15f2008-08-08 21:10:16 +0000975 struct oplock_q_entry, qhead);
976 cFYI(1, ("found oplock item to write out"));
977 pTcon = oplock_item->tcon;
978 inode = oplock_item->pinode;
979 netfid = oplock_item->netfid;
980 spin_unlock(&GlobalMid_Lock);
981 DeleteOplockQEntry(oplock_item);
982 /* can not grab inode sem here since it would
Steve French6dc0f872007-07-06 23:13:06 +0000983 deadlock when oplock received on delete
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800984 since vfs_unlink holds the i_mutex across
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 the call */
Steve Frenchad8b15f2008-08-08 21:10:16 +0000986 /* mutex_lock(&inode->i_mutex);*/
987 if (S_ISREG(inode->i_mode)) {
Steve French84210e92008-10-23 04:42:37 +0000988#ifdef CONFIG_CIFS_EXPERIMENTAL
989 if (CIFS_I(inode)->clientCanCacheAll == 0)
990 break_lease(inode, FMODE_READ);
991 else if (CIFS_I(inode)->clientCanCacheRead == 0)
992 break_lease(inode, FMODE_WRITE);
993#endif
Steve Frenchad8b15f2008-08-08 21:10:16 +0000994 rc = filemap_fdatawrite(inode->i_mapping);
995 if (CIFS_I(inode)->clientCanCacheRead == 0) {
996 waitrc = filemap_fdatawait(
997 inode->i_mapping);
998 invalidate_remote_inode(inode);
999 }
1000 if (rc == 0)
1001 rc = waitrc;
1002 } else
1003 rc = 0;
1004 /* mutex_unlock(&inode->i_mutex);*/
1005 if (rc)
1006 CIFS_I(inode)->write_behind_rc = rc;
1007 cFYI(1, ("Oplock flush inode %p rc %d",
1008 inode, rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009
Steve French6dc0f872007-07-06 23:13:06 +00001010 /* releasing stale oplock after recent reconnect
1011 of smb session using a now incorrect file
1012 handle is not a data integrity issue but do
1013 not bother sending an oplock release if session
1014 to server still is disconnected since oplock
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 already released by the server in that case */
Steve Frenchad8b15f2008-08-08 21:10:16 +00001016 if (pTcon->tidStatus != CifsNeedReconnect) {
1017 rc = CIFSSMBLock(0, pTcon, netfid,
1018 0 /* len */ , 0 /* offset */, 0,
1019 0, LOCKING_ANDX_OPLOCK_RELEASE,
1020 false /* wait flag */);
1021 cFYI(1, ("Oplock release rc = %d", rc));
1022 }
Steve French68058e72005-10-10 10:34:22 -07001023 set_current_state(TASK_INTERRUPTIBLE);
1024 schedule_timeout(1); /* yield in case q were corrupt */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 }
Steve French45af7a02006-04-21 22:52:25 +00001026 } while (!kthread_should_stop());
1027
1028 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029}
1030
Steve French50c2f752007-07-13 00:33:32 +00001031static int cifs_dnotify_thread(void *dummyarg)
Steve French8d0d5092005-08-18 09:41:43 -07001032{
Steve French6ab16d22005-11-29 20:55:11 -08001033 struct list_head *tmp;
1034 struct cifsSesInfo *ses;
1035
Steve French8d0d5092005-08-18 09:41:43 -07001036 do {
Pavel Machek0fd1ffe2006-06-13 21:31:39 +00001037 if (try_to_freeze())
Steve French16abbec2005-08-30 13:10:14 -07001038 continue;
Steve French8d0d5092005-08-18 09:41:43 -07001039 set_current_state(TASK_INTERRUPTIBLE);
Steve French6ab16d22005-11-29 20:55:11 -08001040 schedule_timeout(15*HZ);
1041 read_lock(&GlobalSMBSeslock);
1042 /* check if any stuck requests that need
1043 to be woken up and wakeq so the
1044 thread can wake up and error out */
1045 list_for_each(tmp, &GlobalSMBSessionList) {
Steve French6dc0f872007-07-06 23:13:06 +00001046 ses = list_entry(tmp, struct cifsSesInfo,
Steve French6ab16d22005-11-29 20:55:11 -08001047 cifsSessionList);
Steve Frenchad8b15f2008-08-08 21:10:16 +00001048 if (ses->server && atomic_read(&ses->server->inFlight))
Steve French6ab16d22005-11-29 20:55:11 -08001049 wake_up_all(&ses->server->response_q);
1050 }
1051 read_unlock(&GlobalSMBSeslock);
Steve French45af7a02006-04-21 22:52:25 +00001052 } while (!kthread_should_stop());
1053
1054 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055}
1056
1057static int __init
1058init_cifs(void)
1059{
1060 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 cifs_proc_init();
Steve French2cd646a2006-09-28 19:43:08 +00001062/* INIT_LIST_HEAD(&GlobalServerList);*/ /* BB not implemented yet */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 INIT_LIST_HEAD(&GlobalSMBSessionList);
1064 INIT_LIST_HEAD(&GlobalTreeConnectionList);
1065 INIT_LIST_HEAD(&GlobalOplock_Q);
Steve French4ca9c192005-10-10 19:52:13 -07001066#ifdef CONFIG_CIFS_EXPERIMENTAL
1067 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1068 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
Steve French6dc0f872007-07-06 23:13:06 +00001069#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070/*
1071 * Initialize Global counters
1072 */
1073 atomic_set(&sesInfoAllocCount, 0);
1074 atomic_set(&tconInfoAllocCount, 0);
Steve French6dc0f872007-07-06 23:13:06 +00001075 atomic_set(&tcpSesAllocCount, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 atomic_set(&tcpSesReconnectCount, 0);
1077 atomic_set(&tconInfoReconnectCount, 0);
1078
1079 atomic_set(&bufAllocCount, 0);
Steve French4498eed2005-12-03 13:58:57 -08001080 atomic_set(&smBufAllocCount, 0);
1081#ifdef CONFIG_CIFS_STATS2
1082 atomic_set(&totBufAllocCount, 0);
1083 atomic_set(&totSmBufAllocCount, 0);
1084#endif /* CONFIG_CIFS_STATS2 */
1085
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 atomic_set(&midCount, 0);
1087 GlobalCurrentXid = 0;
1088 GlobalTotalActiveXid = 0;
1089 GlobalMaxActiveXid = 0;
Steve French2cd646a2006-09-28 19:43:08 +00001090 memset(Local_System_Name, 0, 15);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 rwlock_init(&GlobalSMBSeslock);
1092 spin_lock_init(&GlobalMid_Lock);
1093
Steve French4523cc32007-04-30 20:13:06 +00001094 if (cifs_max_pending < 2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 cifs_max_pending = 2;
Steve French6dc0f872007-07-06 23:13:06 +00001096 cFYI(1, ("cifs_max_pending set to min of 2"));
Steve French4523cc32007-04-30 20:13:06 +00001097 } else if (cifs_max_pending > 256) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 cifs_max_pending = 256;
Steve French6dc0f872007-07-06 23:13:06 +00001099 cFYI(1, ("cifs_max_pending set to max of 256"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 }
1101
1102 rc = cifs_init_inodecache();
Steve French45af7a02006-04-21 22:52:25 +00001103 if (rc)
1104 goto out_clean_proc;
1105
1106 rc = cifs_init_mids();
1107 if (rc)
1108 goto out_destroy_inodecache;
1109
1110 rc = cifs_init_request_bufs();
1111 if (rc)
1112 goto out_destroy_mids;
1113
1114 rc = register_filesystem(&cifs_fs_type);
1115 if (rc)
1116 goto out_destroy_request_bufs;
Jeff Layton84a15b92007-11-03 05:02:24 +00001117#ifdef CONFIG_CIFS_UPCALL
1118 rc = register_key_type(&cifs_spnego_key_type);
1119 if (rc)
1120 goto out_unregister_filesystem;
1121#endif
Steve French61033352008-01-09 16:21:36 +00001122#ifdef CONFIG_CIFS_DFS_UPCALL
1123 rc = register_key_type(&key_type_dns_resolver);
1124 if (rc)
1125 goto out_unregister_key_type;
1126#endif
Steve French45af7a02006-04-21 22:52:25 +00001127 oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
1128 if (IS_ERR(oplockThread)) {
1129 rc = PTR_ERR(oplockThread);
Steve French6dc0f872007-07-06 23:13:06 +00001130 cERROR(1, ("error %d create oplock thread", rc));
Steve French61033352008-01-09 16:21:36 +00001131 goto out_unregister_dfs_key_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 }
Steve French45af7a02006-04-21 22:52:25 +00001133
1134 dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
1135 if (IS_ERR(dnotifyThread)) {
1136 rc = PTR_ERR(dnotifyThread);
Steve French6dc0f872007-07-06 23:13:06 +00001137 cERROR(1, ("error %d create dnotify thread", rc));
Steve French45af7a02006-04-21 22:52:25 +00001138 goto out_stop_oplock_thread;
1139 }
1140
1141 return 0;
1142
1143 out_stop_oplock_thread:
1144 kthread_stop(oplockThread);
Steve French61033352008-01-09 16:21:36 +00001145 out_unregister_dfs_key_type:
1146#ifdef CONFIG_CIFS_DFS_UPCALL
1147 unregister_key_type(&key_type_dns_resolver);
Jeff Layton84a15b92007-11-03 05:02:24 +00001148 out_unregister_key_type:
Steve French61033352008-01-09 16:21:36 +00001149#endif
Jeff Layton84a15b92007-11-03 05:02:24 +00001150#ifdef CONFIG_CIFS_UPCALL
1151 unregister_key_type(&cifs_spnego_key_type);
Steve French45af7a02006-04-21 22:52:25 +00001152 out_unregister_filesystem:
Jeff Layton84a15b92007-11-03 05:02:24 +00001153#endif
Steve French45af7a02006-04-21 22:52:25 +00001154 unregister_filesystem(&cifs_fs_type);
1155 out_destroy_request_bufs:
1156 cifs_destroy_request_bufs();
1157 out_destroy_mids:
1158 cifs_destroy_mids();
1159 out_destroy_inodecache:
1160 cifs_destroy_inodecache();
1161 out_clean_proc:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 cifs_proc_clean();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 return rc;
1164}
1165
1166static void __exit
1167exit_cifs(void)
1168{
Steve French90c81e02008-02-12 20:32:36 +00001169 cFYI(DBG2, ("exit_cifs"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 cifs_proc_clean();
Steve French61033352008-01-09 16:21:36 +00001171#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov78d31a32008-04-24 12:56:07 +04001172 cifs_dfs_release_automount_timer();
Steve French61033352008-01-09 16:21:36 +00001173 unregister_key_type(&key_type_dns_resolver);
1174#endif
Jeff Layton84a15b92007-11-03 05:02:24 +00001175#ifdef CONFIG_CIFS_UPCALL
1176 unregister_key_type(&cifs_spnego_key_type);
1177#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 unregister_filesystem(&cifs_fs_type);
1179 cifs_destroy_inodecache();
1180 cifs_destroy_mids();
1181 cifs_destroy_request_bufs();
Steve French45af7a02006-04-21 22:52:25 +00001182 kthread_stop(oplockThread);
1183 kthread_stop(dnotifyThread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184}
1185
1186MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
Steve French6dc0f872007-07-06 23:13:06 +00001187MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188MODULE_DESCRIPTION
Steve French63135e02007-07-17 17:34:02 +00001189 ("VFS to access servers complying with the SNIA CIFS Specification "
1190 "e.g. Samba and Windows");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191MODULE_VERSION(CIFS_VERSION);
1192module_init(init_cifs)
1193module_exit(exit_cifs)