blob: c7c3521aa7cddc601170b4f6e716e996f98d62c7 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/cifsfs.c
3 *
Steve French35c11fd2007-02-27 05:09:35 +00004 * Copyright (C) International Business Machines Corp., 2002,2007
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>
46#define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
47
48#ifdef CONFIG_CIFS_QUOTA
49static struct quotactl_ops cifs_quotactl_ops;
Steve French35c11fd2007-02-27 05:09:35 +000050#endif /* QUOTA */
51
52#ifdef CONFIG_CIFS_EXPERIMENTAL
53extern struct export_operations cifs_export_ops;
54#endif /* EXPERIMENTAL */
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
56int cifsFYI = 0;
57int cifsERROR = 1;
58int traceSMB = 0;
59unsigned int oplockEnabled = 1;
60unsigned int experimEnabled = 0;
61unsigned int linuxExtEnabled = 1;
62unsigned int lookupCacheEnabled = 1;
63unsigned int multiuser_mount = 0;
Steve French39798772006-05-31 22:40:51 +000064unsigned int extended_security = CIFSSEC_DEF;
65/* unsigned int ntlmv2_support = 0; */
Linus Torvalds1da177e2005-04-16 15:20:36 -070066unsigned int sign_CIFS_PDUs = 1;
Steve French6dc0f872007-07-06 23:13:06 +000067extern struct task_struct *oplockThread; /* remove sparse warning */
68struct task_struct *oplockThread = NULL;
Steve French99ee4db2007-02-27 05:35:17 +000069/* extern struct task_struct * dnotifyThread; remove sparse warning */
Steve French6dc0f872007-07-06 23:13:06 +000070static struct task_struct *dnotifyThread = NULL;
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -080071static const struct super_operations cifs_super_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070072unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
73module_param(CIFSMaxBufSize, int, 0);
Steve French63135e02007-07-17 17:34:02 +000074MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
75 "Default: 16384 Range: 8192 to 130048");
Linus Torvalds1da177e2005-04-16 15:20:36 -070076unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
77module_param(cifs_min_rcv, int, 0);
Steve French63135e02007-07-17 17:34:02 +000078MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
79 "1 to 64");
Linus Torvalds1da177e2005-04-16 15:20:36 -070080unsigned int cifs_min_small = 30;
81module_param(cifs_min_small, int, 0);
Steve French63135e02007-07-17 17:34:02 +000082MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
83 "Range: 2 to 256");
Linus Torvalds1da177e2005-04-16 15:20:36 -070084unsigned int cifs_max_pending = CIFS_MAX_REQ;
85module_param(cifs_max_pending, int, 0);
Steve French63135e02007-07-17 17:34:02 +000086MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
87 "Default: 50 Range: 2 to 256");
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
Linus Torvalds1da177e2005-04-16 15:20:36 -070089extern mempool_t *cifs_sm_req_poolp;
90extern mempool_t *cifs_req_poolp;
91extern mempool_t *cifs_mid_poolp;
92
Christoph Lametere18b8902006-12-06 20:33:20 -080093extern struct kmem_cache *cifs_oplock_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
95static int
96cifs_read_super(struct super_block *sb, void *data,
97 const char *devname, int silent)
98{
99 struct inode *inode;
100 struct cifs_sb_info *cifs_sb;
101 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +0000102
Steve French1b2b2122007-02-17 04:30:54 +0000103 /* BB should we make this contingent on mount parm? */
104 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
Steve French790fe572007-07-07 19:25:05 +0000105 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 cifs_sb = CIFS_SB(sb);
Steve French4523cc32007-04-30 20:13:06 +0000107 if (cifs_sb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
110 rc = cifs_mount(sb, cifs_sb, data, devname);
111
112 if (rc) {
113 if (!silent)
114 cERROR(1,
115 ("cifs_mount failed w/return code = %d", rc));
116 goto out_mount_failed;
117 }
118
119 sb->s_magic = CIFS_MAGIC_NUMBER;
120 sb->s_op = &cifs_super_ops;
Steve French4523cc32007-04-30 20:13:06 +0000121/* if (cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
Steve French790fe572007-07-07 19:25:05 +0000122 sb->s_blocksize =
123 cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124#ifdef CONFIG_CIFS_QUOTA
125 sb->s_qcop = &cifs_quotactl_ops;
126#endif
127 sb->s_blocksize = CIFS_MAX_MSGSIZE;
128 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
129 inode = iget(sb, ROOT_I);
130
131 if (!inode) {
132 rc = -ENOMEM;
133 goto out_no_root;
134 }
135
136 sb->s_root = d_alloc_root(inode);
137
138 if (!sb->s_root) {
139 rc = -ENOMEM;
140 goto out_no_root;
141 }
Steve French50c2f752007-07-13 00:33:32 +0000142
Steve French7521a3c2007-07-11 18:30:34 +0000143#ifdef CONFIG_CIFS_EXPERIMENTAL
144 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
145 cFYI(1, ("export ops supported"));
146 sb->s_export_op = &cifs_export_ops;
147 }
148#endif /* EXPERIMENTAL */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
150 return 0;
151
152out_no_root:
153 cERROR(1, ("cifs_read_super: get root inode failed"));
154 if (inode)
155 iput(inode);
156
157out_mount_failed:
Steve French4523cc32007-04-30 20:13:06 +0000158 if (cifs_sb) {
159 if (cifs_sb->local_nls)
Steve French50c2f752007-07-13 00:33:32 +0000160 unload_nls(cifs_sb->local_nls);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 kfree(cifs_sb);
162 }
163 return rc;
164}
165
166static void
167cifs_put_super(struct super_block *sb)
168{
169 int rc = 0;
170 struct cifs_sb_info *cifs_sb;
171
172 cFYI(1, ("In cifs_put_super"));
173 cifs_sb = CIFS_SB(sb);
Steve French4523cc32007-04-30 20:13:06 +0000174 if (cifs_sb == NULL) {
Steve French790fe572007-07-07 19:25:05 +0000175 cFYI(1, ("Empty cifs superblock info passed to unmount"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 return;
177 }
Steve French790fe572007-07-07 19:25:05 +0000178 rc = cifs_umount(sb, cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 if (rc) {
180 cERROR(1, ("cifs_umount failed with return code %d", rc));
181 }
182 unload_nls(cifs_sb->local_nls);
183 kfree(cifs_sb);
184 return;
185}
186
187static int
David Howells726c3342006-06-23 02:02:58 -0700188cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189{
David Howells726c3342006-06-23 02:02:58 -0700190 struct super_block *sb = dentry->d_sb;
Steve French790fe572007-07-07 19:25:05 +0000191 int xid;
Steve Frenchc81156d2005-04-28 22:41:07 -0700192 int rc = -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 struct cifs_sb_info *cifs_sb;
194 struct cifsTconInfo *pTcon;
195
196 xid = GetXid();
197
198 cifs_sb = CIFS_SB(sb);
199 pTcon = cifs_sb->tcon;
200
201 buf->f_type = CIFS_MAGIC_NUMBER;
202
203 /* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */
Steve French790fe572007-07-07 19:25:05 +0000204 buf->f_namelen = PATH_MAX; /* PATH_MAX may be too long - it would
Steve Frenchc81156d2005-04-28 22:41:07 -0700205 presumably be total path, but note
206 that some servers (includinng Samba 3)
207 have a shorter maximum path */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 buf->f_files = 0; /* undefined */
209 buf->f_ffree = 0; /* unlimited */
210
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211/* BB we could add a second check for a QFS Unix capability bit */
Steve Frenchf28ac912005-04-28 22:41:07 -0700212/* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */
Steve Frenchc81156d2005-04-28 22:41:07 -0700213 if ((pTcon->ses->capabilities & CAP_UNIX) && (CIFS_POSIX_EXTENSIONS &
214 le64_to_cpu(pTcon->fsUnixInfo.Capability)))
Steve French737b7582005-04-28 22:41:06 -0700215 rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
217 /* Only need to call the old QFSInfo if failed
218 on newer one */
Steve French4523cc32007-04-30 20:13:06 +0000219 if (rc)
220 if (pTcon->ses->capabilities & CAP_NT_SMBS)
Steve French9ac00b72006-09-30 04:13:17 +0000221 rc = CIFSSMBQFSInfo(xid, pTcon, buf); /* not supported by OS2 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
Steve French9ac00b72006-09-30 04:13:17 +0000223 /* Some old Windows servers also do not support level 103, retry with
224 older level one if old server failed the previous call or we
225 bypassed it because we detected that this was an older LANMAN sess */
Steve French4523cc32007-04-30 20:13:06 +0000226 if (rc)
Steve French20962432005-09-21 22:05:57 -0700227 rc = SMBOldQFSInfo(xid, pTcon, buf);
Steve French790fe572007-07-07 19:25:05 +0000228 /* int f_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 __fsid_t f_fsid;
230 int f_namelen; */
Steve Frenchc81156d2005-04-28 22:41:07 -0700231 /* BB get from info in tcon struct at mount time call to QFSAttrInfo */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 FreeXid(xid);
Steve Frenchc81156d2005-04-28 22:41:07 -0700233 return 0; /* always return success? what if volume is no
234 longer available? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235}
236
Steve French50c2f752007-07-13 00:33:32 +0000237static int cifs_permission(struct inode *inode, int mask, struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238{
239 struct cifs_sb_info *cifs_sb;
240
241 cifs_sb = CIFS_SB(inode->i_sb);
242
Steve French26f57362007-08-30 22:09:15 +0000243 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 return 0;
Steve French26f57362007-08-30 22:09:15 +0000245 else /* file mode might have been restricted at mount time
Steve French50c2f752007-07-13 00:33:32 +0000246 on the client (above and beyond ACL on servers) for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 servers which do not support setting and viewing mode bits,
Steve French50c2f752007-07-13 00:33:32 +0000248 so allowing client to check permissions is useful */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 return generic_permission(inode, mask, NULL);
250}
251
Christoph Lametere18b8902006-12-06 20:33:20 -0800252static struct kmem_cache *cifs_inode_cachep;
253static struct kmem_cache *cifs_req_cachep;
254static struct kmem_cache *cifs_mid_cachep;
255struct kmem_cache *cifs_oplock_cachep;
256static struct kmem_cache *cifs_sm_req_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257mempool_t *cifs_sm_req_poolp;
258mempool_t *cifs_req_poolp;
259mempool_t *cifs_mid_poolp;
260
261static struct inode *
262cifs_alloc_inode(struct super_block *sb)
263{
264 struct cifsInodeInfo *cifs_inode;
Christoph Lametere94b1762006-12-06 20:33:17 -0800265 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 if (!cifs_inode)
267 return NULL;
268 cifs_inode->cifsAttrs = 0x20; /* default */
269 atomic_set(&cifs_inode->inUse, 0);
270 cifs_inode->time = 0;
271 /* Until the file is open and we have gotten oplock
272 info back from the server, can not assume caching of
273 file data or metadata */
274 cifs_inode->clientCanCacheRead = FALSE;
275 cifs_inode->clientCanCacheAll = FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
Steve French50c2f752007-07-13 00:33:32 +0000277
Steve French1b2b2122007-02-17 04:30:54 +0000278 /* Can not set i_flags here - they get immediately overwritten
279 to zero by the VFS */
280/* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 INIT_LIST_HEAD(&cifs_inode->openFileList);
282 return &cifs_inode->vfs_inode;
283}
284
285static void
286cifs_destroy_inode(struct inode *inode)
287{
288 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
289}
290
291/*
292 * cifs_show_options() is for displaying mount options in /proc/mounts.
293 * Not all settable options are displayed but most of the important
294 * ones are.
295 */
296static int
297cifs_show_options(struct seq_file *s, struct vfsmount *m)
298{
299 struct cifs_sb_info *cifs_sb;
300
301 cifs_sb = CIFS_SB(m->mnt_sb);
302
303 if (cifs_sb) {
304 if (cifs_sb->tcon) {
Steve French004c46b2007-02-17 04:34:13 +0000305/* BB add prepath to mount options displayed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
307 if (cifs_sb->tcon->ses) {
308 if (cifs_sb->tcon->ses->userName)
309 seq_printf(s, ",username=%s",
310 cifs_sb->tcon->ses->userName);
Steve French4523cc32007-04-30 20:13:06 +0000311 if (cifs_sb->tcon->ses->domainName)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 seq_printf(s, ",domain=%s",
313 cifs_sb->tcon->ses->domainName);
314 }
315 }
Steve French4523cc32007-04-30 20:13:06 +0000316 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
317 seq_printf(s, ",posixpaths");
318 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) ||
Steve Frenchc18c8422007-07-18 23:21:09 +0000319 !(cifs_sb->tcon->unix_ext))
Steve French4523cc32007-04-30 20:13:06 +0000320 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
321 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) ||
Steve Frenchc18c8422007-07-18 23:21:09 +0000322 !(cifs_sb->tcon->unix_ext))
Steve French4523cc32007-04-30 20:13:06 +0000323 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
Steve French50c2f752007-07-13 00:33:32 +0000324 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
325 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 }
327 return 0;
328}
329
330#ifdef CONFIG_CIFS_QUOTA
Steve French50c2f752007-07-13 00:33:32 +0000331int cifs_xquota_set(struct super_block *sb, int quota_type, qid_t qid,
332 struct fs_disk_quota *pdquota)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333{
334 int xid;
335 int rc = 0;
336 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
337 struct cifsTconInfo *pTcon;
Steve French50c2f752007-07-13 00:33:32 +0000338
Steve French4523cc32007-04-30 20:13:06 +0000339 if (cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 pTcon = cifs_sb->tcon;
341 else
342 return -EIO;
343
344
345 xid = GetXid();
Steve French4523cc32007-04-30 20:13:06 +0000346 if (pTcon) {
Steve French50c2f752007-07-13 00:33:32 +0000347 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 } else {
Cyrill Gorcunov95ba7362007-08-24 00:23:36 +0000349 rc = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 }
351
352 FreeXid(xid);
353 return rc;
354}
355
Steve French50c2f752007-07-13 00:33:32 +0000356int cifs_xquota_get(struct super_block *sb, int quota_type, qid_t qid,
357 struct fs_disk_quota *pdquota)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358{
359 int xid;
360 int rc = 0;
361 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
362 struct cifsTconInfo *pTcon;
363
Steve French4523cc32007-04-30 20:13:06 +0000364 if (cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 pTcon = cifs_sb->tcon;
366 else
367 return -EIO;
368
369 xid = GetXid();
Steve French4523cc32007-04-30 20:13:06 +0000370 if (pTcon) {
Steve French50c2f752007-07-13 00:33:32 +0000371 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 } else {
373 rc = -EIO;
374 }
375
376 FreeXid(xid);
377 return rc;
378}
379
Steve French50c2f752007-07-13 00:33:32 +0000380int cifs_xstate_set(struct super_block *sb, unsigned int flags, int operation)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381{
Steve French50c2f752007-07-13 00:33:32 +0000382 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 int rc = 0;
384 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
385 struct cifsTconInfo *pTcon;
386
Steve French4523cc32007-04-30 20:13:06 +0000387 if (cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 pTcon = cifs_sb->tcon;
389 else
390 return -EIO;
391
392 xid = GetXid();
Steve French4523cc32007-04-30 20:13:06 +0000393 if (pTcon) {
Steve French50c2f752007-07-13 00:33:32 +0000394 cFYI(1, ("flags: 0x%x operation: 0x%x", flags, operation));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 } else {
396 rc = -EIO;
397 }
398
399 FreeXid(xid);
400 return rc;
401}
402
Steve French50c2f752007-07-13 00:33:32 +0000403int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404{
405 int xid;
406 int rc = 0;
407 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
408 struct cifsTconInfo *pTcon;
409
Steve French4523cc32007-04-30 20:13:06 +0000410 if (cifs_sb) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 pTcon = cifs_sb->tcon;
412 } else {
413 return -EIO;
414 }
415 xid = GetXid();
Steve French4523cc32007-04-30 20:13:06 +0000416 if (pTcon) {
Steve French50c2f752007-07-13 00:33:32 +0000417 cFYI(1, ("pqstats %p", qstats));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 } else {
419 rc = -EIO;
420 }
421
422 FreeXid(xid);
423 return rc;
424}
425
426static struct quotactl_ops cifs_quotactl_ops = {
427 .set_xquota = cifs_xquota_set,
428 .get_xquota = cifs_xquota_set,
429 .set_xstate = cifs_xstate_set,
430 .get_xstate = cifs_xstate_get,
431};
432#endif
433
Steve French50c2f752007-07-13 00:33:32 +0000434static void cifs_umount_begin(struct vfsmount *vfsmnt, int flags)
Steve French68058e72005-10-10 10:34:22 -0700435{
Steve French5e1253b2005-10-10 14:06:37 -0700436 struct cifs_sb_info *cifs_sb;
Steve French50c2f752007-07-13 00:33:32 +0000437 struct cifsTconInfo *tcon;
Steve French68058e72005-10-10 10:34:22 -0700438
Trond Myklebust8b512d92006-06-09 09:34:18 -0400439 if (!(flags & MNT_FORCE))
440 return;
441 cifs_sb = CIFS_SB(vfsmnt->mnt_sb);
Steve French4523cc32007-04-30 20:13:06 +0000442 if (cifs_sb == NULL)
Steve French9e2e85f2005-10-10 14:28:38 -0700443 return;
444
445 tcon = cifs_sb->tcon;
Steve French4523cc32007-04-30 20:13:06 +0000446 if (tcon == NULL)
Steve French9e2e85f2005-10-10 14:28:38 -0700447 return;
Steve French5e1253b2005-10-10 14:06:37 -0700448 down(&tcon->tconSem);
449 if (atomic_read(&tcon->useCount) == 1)
450 tcon->tidStatus = CifsExiting;
451 up(&tcon->tconSem);
452
Steve French3a5ff612006-07-14 22:37:11 +0000453 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
Steve French7b7abfe2005-11-09 15:21:09 -0800454 /* cancel_notify_requests(tcon); */
Steve French50c2f752007-07-13 00:33:32 +0000455 if (tcon->ses && tcon->ses->server) {
456 cFYI(1, ("wake up tasks now - umount begin not complete"));
Steve French9e2e85f2005-10-10 14:28:38 -0700457 wake_up_all(&tcon->ses->server->request_q);
Steve French6ab16d22005-11-29 20:55:11 -0800458 wake_up_all(&tcon->ses->server->response_q);
459 msleep(1); /* yield */
460 /* we have to kick the requests once more */
461 wake_up_all(&tcon->ses->server->response_q);
462 msleep(1);
Steve French5e1253b2005-10-10 14:06:37 -0700463 }
464/* BB FIXME - finish add checks for tidStatus BB */
Steve French68058e72005-10-10 10:34:22 -0700465
466 return;
467}
Steve French68058e72005-10-10 10:34:22 -0700468
Steve Frenchbf97d282006-09-28 21:34:06 +0000469#ifdef CONFIG_CIFS_STATS2
470static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
471{
472 /* BB FIXME */
473 return 0;
474}
475#endif
476
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477static int cifs_remount(struct super_block *sb, int *flags, char *data)
478{
479 *flags |= MS_NODIRATIME;
480 return 0;
481}
482
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800483static const struct super_operations cifs_super_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 .read_inode = cifs_read_inode,
485 .put_super = cifs_put_super,
486 .statfs = cifs_statfs,
487 .alloc_inode = cifs_alloc_inode,
488 .destroy_inode = cifs_destroy_inode,
Steve French50c2f752007-07-13 00:33:32 +0000489/* .drop_inode = generic_delete_inode,
490 .delete_inode = cifs_delete_inode, */ /* Do not need above two
491 functions unless later we add lazy close of inodes or unless the
492 kernel forgets to call us with the same number of releases (closes)
493 as opens */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 .show_options = cifs_show_options,
Steve French7b7abfe2005-11-09 15:21:09 -0800495 .umount_begin = cifs_umount_begin,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 .remount_fs = cifs_remount,
Steve Frenchbf97d282006-09-28 21:34:06 +0000497#ifdef CONFIG_CIFS_STATS2
Steve Frenchf46d3e12006-09-30 01:08:55 +0000498 .show_stats = cifs_show_stats,
Steve Frenchbf97d282006-09-28 21:34:06 +0000499#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500};
501
David Howells454e2392006-06-23 02:02:57 -0700502static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503cifs_get_sb(struct file_system_type *fs_type,
David Howells454e2392006-06-23 02:02:57 -0700504 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505{
506 int rc;
507 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
508
509 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
510
511 if (IS_ERR(sb))
David Howells454e2392006-06-23 02:02:57 -0700512 return PTR_ERR(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513
514 sb->s_flags = flags;
515
Theodore Ts'o9b04c992006-03-24 03:15:10 -0800516 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 if (rc) {
518 up_write(&sb->s_umount);
519 deactivate_super(sb);
David Howells454e2392006-06-23 02:02:57 -0700520 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 }
522 sb->s_flags |= MS_ACTIVE;
David Howells454e2392006-06-23 02:02:57 -0700523 return simple_set_mnt(mnt, sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524}
525
Badari Pulavarty027445c2006-09-30 23:28:46 -0700526static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
527 unsigned long nr_segs, loff_t pos)
Steve French87c89dd2005-11-17 17:03:00 -0800528{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800529 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
Steve French87c89dd2005-11-17 17:03:00 -0800530 ssize_t written;
531
Badari Pulavarty027445c2006-09-30 23:28:46 -0700532 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
Steve French87c89dd2005-11-17 17:03:00 -0800533 if (!CIFS_I(inode)->clientCanCacheAll)
534 filemap_fdatawrite(inode->i_mapping);
535 return written;
536}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537
Steve Frenchc32a0b62006-01-12 14:41:28 -0800538static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
539{
540 /* origin == SEEK_END => we must revalidate the cached file length */
Steve French0889a942006-09-23 22:11:07 +0000541 if (origin == SEEK_END) {
Steve French030e9d82007-02-01 04:27:59 +0000542 int retval;
543
544 /* some applications poll for the file length in this strange
545 way so we must seek to end on non-oplocked files by
546 setting the revalidate time to zero */
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000547 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
Steve French030e9d82007-02-01 04:27:59 +0000548
549 retval = cifs_revalidate(file->f_path.dentry);
Steve Frenchc32a0b62006-01-12 14:41:28 -0800550 if (retval < 0)
551 return (loff_t)retval;
552 }
553 return remote_llseek(file, offset, origin);
554}
555
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556static struct file_system_type cifs_fs_type = {
557 .owner = THIS_MODULE,
558 .name = "cifs",
559 .get_sb = cifs_get_sb,
560 .kill_sb = kill_anon_super,
561 /* .fs_flags */
562};
Arjan van de Ven754661f2007-02-12 00:55:38 -0800563const struct inode_operations cifs_dir_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 .create = cifs_create,
565 .lookup = cifs_lookup,
566 .getattr = cifs_getattr,
567 .unlink = cifs_unlink,
568 .link = cifs_hardlink,
569 .mkdir = cifs_mkdir,
570 .rmdir = cifs_rmdir,
571 .rename = cifs_rename,
572 .permission = cifs_permission,
573/* revalidate:cifs_revalidate, */
574 .setattr = cifs_setattr,
575 .symlink = cifs_symlink,
576 .mknod = cifs_mknod,
577#ifdef CONFIG_CIFS_XATTR
578 .setxattr = cifs_setxattr,
579 .getxattr = cifs_getxattr,
580 .listxattr = cifs_listxattr,
581 .removexattr = cifs_removexattr,
582#endif
583};
584
Arjan van de Ven754661f2007-02-12 00:55:38 -0800585const struct inode_operations cifs_file_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586/* revalidate:cifs_revalidate, */
587 .setattr = cifs_setattr,
588 .getattr = cifs_getattr, /* do we need this anymore? */
589 .rename = cifs_rename,
590 .permission = cifs_permission,
591#ifdef CONFIG_CIFS_XATTR
592 .setxattr = cifs_setxattr,
593 .getxattr = cifs_getxattr,
594 .listxattr = cifs_listxattr,
595 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000596#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597};
598
Arjan van de Ven754661f2007-02-12 00:55:38 -0800599const struct inode_operations cifs_symlink_inode_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000600 .readlink = generic_readlink,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 .follow_link = cifs_follow_link,
602 .put_link = cifs_put_link,
603 .permission = cifs_permission,
604 /* BB add the following two eventually */
605 /* revalidate: cifs_revalidate,
606 setattr: cifs_notify_change, *//* BB do we need notify change */
607#ifdef CONFIG_CIFS_XATTR
608 .setxattr = cifs_setxattr,
609 .getxattr = cifs_getxattr,
610 .listxattr = cifs_listxattr,
611 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000612#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613};
614
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800615const struct file_operations cifs_file_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800616 .read = do_sync_read,
617 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800618 .aio_read = generic_file_aio_read,
619 .aio_write = cifs_file_aio_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 .open = cifs_open,
621 .release = cifs_close,
622 .lock = cifs_lock,
623 .fsync = cifs_fsync,
624 .flush = cifs_flush,
625 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200626 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800627 .llseek = cifs_llseek,
Steve Frenchc67593a2005-04-28 22:41:04 -0700628#ifdef CONFIG_CIFS_POSIX
629 .ioctl = cifs_ioctl,
630#endif /* CONFIG_CIFS_POSIX */
631
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632#ifdef CONFIG_CIFS_EXPERIMENTAL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 .dir_notify = cifs_dir_notify,
634#endif /* CONFIG_CIFS_EXPERIMENTAL */
635};
636
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800637const struct file_operations cifs_file_direct_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000638 /* no mmap, no aio, no readv -
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 BB reevaluate whether they can be done with directio, no cache */
640 .read = cifs_user_read,
641 .write = cifs_user_write,
642 .open = cifs_open,
643 .release = cifs_close,
644 .lock = cifs_lock,
645 .fsync = cifs_fsync,
646 .flush = cifs_flush,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200647 .splice_read = generic_file_splice_read,
Steve Frenchc67593a2005-04-28 22:41:04 -0700648#ifdef CONFIG_CIFS_POSIX
649 .ioctl = cifs_ioctl,
650#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800651 .llseek = cifs_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652#ifdef CONFIG_CIFS_EXPERIMENTAL
653 .dir_notify = cifs_dir_notify,
654#endif /* CONFIG_CIFS_EXPERIMENTAL */
655};
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800656const struct file_operations cifs_file_nobrl_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800657 .read = do_sync_read,
658 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800659 .aio_read = generic_file_aio_read,
660 .aio_write = cifs_file_aio_write,
661 .open = cifs_open,
662 .release = cifs_close,
663 .fsync = cifs_fsync,
664 .flush = cifs_flush,
665 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200666 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800667 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800668#ifdef CONFIG_CIFS_POSIX
Steve French87c89dd2005-11-17 17:03:00 -0800669 .ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800670#endif /* CONFIG_CIFS_POSIX */
671
672#ifdef CONFIG_CIFS_EXPERIMENTAL
Steve French87c89dd2005-11-17 17:03:00 -0800673 .dir_notify = cifs_dir_notify,
Steve French8b94bcb2005-11-11 11:41:00 -0800674#endif /* CONFIG_CIFS_EXPERIMENTAL */
675};
676
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800677const struct file_operations cifs_file_direct_nobrl_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000678 /* no mmap, no aio, no readv -
Steve French87c89dd2005-11-17 17:03:00 -0800679 BB reevaluate whether they can be done with directio, no cache */
680 .read = cifs_user_read,
681 .write = cifs_user_write,
682 .open = cifs_open,
683 .release = cifs_close,
684 .fsync = cifs_fsync,
685 .flush = cifs_flush,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200686 .splice_read = generic_file_splice_read,
Steve French8b94bcb2005-11-11 11:41:00 -0800687#ifdef CONFIG_CIFS_POSIX
Steve French87c89dd2005-11-17 17:03:00 -0800688 .ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800689#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800690 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800691#ifdef CONFIG_CIFS_EXPERIMENTAL
Steve French87c89dd2005-11-17 17:03:00 -0800692 .dir_notify = cifs_dir_notify,
Steve French8b94bcb2005-11-11 11:41:00 -0800693#endif /* CONFIG_CIFS_EXPERIMENTAL */
694};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800696const struct file_operations cifs_dir_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 .readdir = cifs_readdir,
698 .release = cifs_closedir,
699 .read = generic_read_dir,
700#ifdef CONFIG_CIFS_EXPERIMENTAL
701 .dir_notify = cifs_dir_notify,
702#endif /* CONFIG_CIFS_EXPERIMENTAL */
Steve French50c2f752007-07-13 00:33:32 +0000703 .ioctl = cifs_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704};
705
706static void
Steve French50c2f752007-07-13 00:33:32 +0000707cifs_init_once(void *inode, struct kmem_cache *cachep, unsigned long flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708{
709 struct cifsInodeInfo *cifsi = inode;
710
Christoph Lametera35afb82007-05-16 22:10:57 -0700711 inode_init_once(&cifsi->vfs_inode);
712 INIT_LIST_HEAD(&cifsi->lockList);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713}
714
715static int
716cifs_init_inodecache(void)
717{
718 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
Steve French26f57362007-08-30 22:09:15 +0000719 sizeof(struct cifsInodeInfo),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800720 0, (SLAB_RECLAIM_ACCOUNT|
721 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +0900722 cifs_init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 if (cifs_inode_cachep == NULL)
724 return -ENOMEM;
725
726 return 0;
727}
728
729static void
730cifs_destroy_inodecache(void)
731{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700732 kmem_cache_destroy(cifs_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733}
734
735static int
736cifs_init_request_bufs(void)
737{
Steve French4523cc32007-04-30 20:13:06 +0000738 if (CIFSMaxBufSize < 8192) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
740 Unicode path name has to fit in any SMB/CIFS path based frames */
741 CIFSMaxBufSize = 8192;
742 } else if (CIFSMaxBufSize > 1024*127) {
743 CIFSMaxBufSize = 1024 * 127;
744 } else {
745 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
746 }
747/* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
748 cifs_req_cachep = kmem_cache_create("cifs_request",
749 CIFSMaxBufSize +
750 MAX_CIFS_HDR_SIZE, 0,
Paul Mundt20c2df82007-07-20 10:11:58 +0900751 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 if (cifs_req_cachep == NULL)
753 return -ENOMEM;
754
Steve French4523cc32007-04-30 20:13:06 +0000755 if (cifs_min_rcv < 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 cifs_min_rcv = 1;
757 else if (cifs_min_rcv > 64) {
758 cifs_min_rcv = 64;
Steve French50c2f752007-07-13 00:33:32 +0000759 cERROR(1, ("cifs_min_rcv set to maximum (64)"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 }
761
Matthew Dobson93d23412006-03-26 01:37:50 -0800762 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
763 cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
Steve French4523cc32007-04-30 20:13:06 +0000765 if (cifs_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 kmem_cache_destroy(cifs_req_cachep);
767 return -ENOMEM;
768 }
Steve Frenchec637e32005-12-12 20:53:18 -0800769 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 almost all handle based requests (but not write response, nor is it
771 sufficient for path based requests). A smaller size would have
Steve French50c2f752007-07-13 00:33:32 +0000772 been more efficient (compacting multiple slab items on one 4k page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 for the case in which debug was on, but this larger size allows
774 more SMBs to use small buffer alloc and is still much more
Steve French6dc0f872007-07-06 23:13:06 +0000775 efficient to alloc 1 per page off the slab compared to 17K (5page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 alloc of large cifs buffers even when page debugging is on */
777 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
Steve French6dc0f872007-07-06 23:13:06 +0000778 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +0900779 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 if (cifs_sm_req_cachep == NULL) {
781 mempool_destroy(cifs_req_poolp);
782 kmem_cache_destroy(cifs_req_cachep);
Steve French6dc0f872007-07-06 23:13:06 +0000783 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 }
785
Steve French4523cc32007-04-30 20:13:06 +0000786 if (cifs_min_small < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 cifs_min_small = 2;
788 else if (cifs_min_small > 256) {
789 cifs_min_small = 256;
Steve French6dc0f872007-07-06 23:13:06 +0000790 cFYI(1, ("cifs_min_small set to maximum (256)"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 }
792
Matthew Dobson93d23412006-03-26 01:37:50 -0800793 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
794 cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795
Steve French4523cc32007-04-30 20:13:06 +0000796 if (cifs_sm_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 mempool_destroy(cifs_req_poolp);
798 kmem_cache_destroy(cifs_req_cachep);
799 kmem_cache_destroy(cifs_sm_req_cachep);
800 return -ENOMEM;
801 }
802
803 return 0;
804}
805
806static void
807cifs_destroy_request_bufs(void)
808{
809 mempool_destroy(cifs_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700810 kmem_cache_destroy(cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 mempool_destroy(cifs_sm_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700812 kmem_cache_destroy(cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813}
814
815static int
816cifs_init_mids(void)
817{
818 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
Steve French26f57362007-08-30 22:09:15 +0000819 sizeof(struct mid_q_entry), 0,
820 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 if (cifs_mid_cachep == NULL)
822 return -ENOMEM;
823
Matthew Dobson93d23412006-03-26 01:37:50 -0800824 /* 3 is a reasonable minimum number of simultaneous operations */
825 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
Steve French4523cc32007-04-30 20:13:06 +0000826 if (cifs_mid_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 kmem_cache_destroy(cifs_mid_cachep);
828 return -ENOMEM;
829 }
830
831 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
Steve French26f57362007-08-30 22:09:15 +0000832 sizeof(struct oplock_q_entry), 0,
833 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 if (cifs_oplock_cachep == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 mempool_destroy(cifs_mid_poolp);
Akinobu Mitae6985c72007-06-04 16:14:59 +0000836 kmem_cache_destroy(cifs_mid_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 return -ENOMEM;
838 }
839
840 return 0;
841}
842
843static void
844cifs_destroy_mids(void)
845{
846 mempool_destroy(cifs_mid_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700847 kmem_cache_destroy(cifs_mid_cachep);
848 kmem_cache_destroy(cifs_oplock_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849}
850
Steve French50c2f752007-07-13 00:33:32 +0000851static int cifs_oplock_thread(void *dummyarg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852{
Steve French6dc0f872007-07-06 23:13:06 +0000853 struct oplock_q_entry *oplock_item;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 struct cifsTconInfo *pTcon;
Steve French6dc0f872007-07-06 23:13:06 +0000855 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 __u16 netfid;
857 int rc;
858
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700859 set_freezable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 do {
Steve French6dc0f872007-07-06 23:13:06 +0000861 if (try_to_freeze())
Steve Frenchede13272005-08-30 20:10:14 -0700862 continue;
Steve French50c2f752007-07-13 00:33:32 +0000863
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 spin_lock(&GlobalMid_Lock);
Steve French4523cc32007-04-30 20:13:06 +0000865 if (list_empty(&GlobalOplock_Q)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 spin_unlock(&GlobalMid_Lock);
867 set_current_state(TASK_INTERRUPTIBLE);
868 schedule_timeout(39*HZ);
869 } else {
Steve French6dc0f872007-07-06 23:13:06 +0000870 oplock_item = list_entry(GlobalOplock_Q.next,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 struct oplock_q_entry, qhead);
Steve French4523cc32007-04-30 20:13:06 +0000872 if (oplock_item) {
Steve French50c2f752007-07-13 00:33:32 +0000873 cFYI(1, ("found oplock item to write out"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 pTcon = oplock_item->tcon;
875 inode = oplock_item->pinode;
876 netfid = oplock_item->netfid;
877 spin_unlock(&GlobalMid_Lock);
878 DeleteOplockQEntry(oplock_item);
879 /* can not grab inode sem here since it would
Steve French6dc0f872007-07-06 23:13:06 +0000880 deadlock when oplock received on delete
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800881 since vfs_unlink holds the i_mutex across
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 the call */
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800883 /* mutex_lock(&inode->i_mutex);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 if (S_ISREG(inode->i_mode)) {
Steve French26f57362007-08-30 22:09:15 +0000885 rc =
886 filemap_fdatawrite(inode->i_mapping);
Steve French50c2f752007-07-13 00:33:32 +0000887 if (CIFS_I(inode)->clientCanCacheRead
888 == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 filemap_fdatawait(inode->i_mapping);
890 invalidate_remote_inode(inode);
891 }
892 } else
893 rc = 0;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800894 /* mutex_unlock(&inode->i_mutex);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 if (rc)
896 CIFS_I(inode)->write_behind_rc = rc;
Steve French6dc0f872007-07-06 23:13:06 +0000897 cFYI(1, ("Oplock flush inode %p rc %d",
898 inode, rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899
Steve French6dc0f872007-07-06 23:13:06 +0000900 /* releasing stale oplock after recent reconnect
901 of smb session using a now incorrect file
902 handle is not a data integrity issue but do
903 not bother sending an oplock release if session
904 to server still is disconnected since oplock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 already released by the server in that case */
Steve French4523cc32007-04-30 20:13:06 +0000906 if (pTcon->tidStatus != CifsNeedReconnect) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 rc = CIFSSMBLock(0, pTcon, netfid,
Steve French6dc0f872007-07-06 23:13:06 +0000908 0 /* len */ , 0 /* offset */, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 0, LOCKING_ANDX_OPLOCK_RELEASE,
910 0 /* wait flag */);
Steve French26f57362007-08-30 22:09:15 +0000911 cFYI(1, ("Oplock release rc = %d", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 }
913 } else
914 spin_unlock(&GlobalMid_Lock);
Steve French68058e72005-10-10 10:34:22 -0700915 set_current_state(TASK_INTERRUPTIBLE);
916 schedule_timeout(1); /* yield in case q were corrupt */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 }
Steve French45af7a02006-04-21 22:52:25 +0000918 } while (!kthread_should_stop());
919
920 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921}
922
Steve French50c2f752007-07-13 00:33:32 +0000923static int cifs_dnotify_thread(void *dummyarg)
Steve French8d0d5092005-08-18 09:41:43 -0700924{
Steve French6ab16d22005-11-29 20:55:11 -0800925 struct list_head *tmp;
926 struct cifsSesInfo *ses;
927
Steve French8d0d5092005-08-18 09:41:43 -0700928 do {
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000929 if (try_to_freeze())
Steve French16abbec2005-08-30 13:10:14 -0700930 continue;
Steve French8d0d5092005-08-18 09:41:43 -0700931 set_current_state(TASK_INTERRUPTIBLE);
Steve French6ab16d22005-11-29 20:55:11 -0800932 schedule_timeout(15*HZ);
933 read_lock(&GlobalSMBSeslock);
934 /* check if any stuck requests that need
935 to be woken up and wakeq so the
936 thread can wake up and error out */
937 list_for_each(tmp, &GlobalSMBSessionList) {
Steve French6dc0f872007-07-06 23:13:06 +0000938 ses = list_entry(tmp, struct cifsSesInfo,
Steve French6ab16d22005-11-29 20:55:11 -0800939 cifsSessionList);
Steve French6dc0f872007-07-06 23:13:06 +0000940 if (ses && ses->server &&
Steve French2a138ebb2005-11-29 21:22:19 -0800941 atomic_read(&ses->server->inFlight))
Steve French6ab16d22005-11-29 20:55:11 -0800942 wake_up_all(&ses->server->response_q);
943 }
944 read_unlock(&GlobalSMBSeslock);
Steve French45af7a02006-04-21 22:52:25 +0000945 } while (!kthread_should_stop());
946
947 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948}
949
950static int __init
951init_cifs(void)
952{
953 int rc = 0;
954#ifdef CONFIG_PROC_FS
955 cifs_proc_init();
956#endif
Steve French2cd646a2006-09-28 19:43:08 +0000957/* INIT_LIST_HEAD(&GlobalServerList);*/ /* BB not implemented yet */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 INIT_LIST_HEAD(&GlobalSMBSessionList);
959 INIT_LIST_HEAD(&GlobalTreeConnectionList);
960 INIT_LIST_HEAD(&GlobalOplock_Q);
Steve French4ca9c192005-10-10 19:52:13 -0700961#ifdef CONFIG_CIFS_EXPERIMENTAL
962 INIT_LIST_HEAD(&GlobalDnotifyReqList);
963 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
Steve French6dc0f872007-07-06 23:13:06 +0000964#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965/*
966 * Initialize Global counters
967 */
968 atomic_set(&sesInfoAllocCount, 0);
969 atomic_set(&tconInfoAllocCount, 0);
Steve French6dc0f872007-07-06 23:13:06 +0000970 atomic_set(&tcpSesAllocCount, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 atomic_set(&tcpSesReconnectCount, 0);
972 atomic_set(&tconInfoReconnectCount, 0);
973
974 atomic_set(&bufAllocCount, 0);
Steve French4498eed52005-12-03 13:58:57 -0800975 atomic_set(&smBufAllocCount, 0);
976#ifdef CONFIG_CIFS_STATS2
977 atomic_set(&totBufAllocCount, 0);
978 atomic_set(&totSmBufAllocCount, 0);
979#endif /* CONFIG_CIFS_STATS2 */
980
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 atomic_set(&midCount, 0);
982 GlobalCurrentXid = 0;
983 GlobalTotalActiveXid = 0;
984 GlobalMaxActiveXid = 0;
Steve French2cd646a2006-09-28 19:43:08 +0000985 memset(Local_System_Name, 0, 15);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 rwlock_init(&GlobalSMBSeslock);
987 spin_lock_init(&GlobalMid_Lock);
988
Steve French4523cc32007-04-30 20:13:06 +0000989 if (cifs_max_pending < 2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 cifs_max_pending = 2;
Steve French6dc0f872007-07-06 23:13:06 +0000991 cFYI(1, ("cifs_max_pending set to min of 2"));
Steve French4523cc32007-04-30 20:13:06 +0000992 } else if (cifs_max_pending > 256) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 cifs_max_pending = 256;
Steve French6dc0f872007-07-06 23:13:06 +0000994 cFYI(1, ("cifs_max_pending set to max of 256"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 }
996
997 rc = cifs_init_inodecache();
Steve French45af7a02006-04-21 22:52:25 +0000998 if (rc)
999 goto out_clean_proc;
1000
1001 rc = cifs_init_mids();
1002 if (rc)
1003 goto out_destroy_inodecache;
1004
1005 rc = cifs_init_request_bufs();
1006 if (rc)
1007 goto out_destroy_mids;
1008
1009 rc = register_filesystem(&cifs_fs_type);
1010 if (rc)
1011 goto out_destroy_request_bufs;
1012
1013 oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
1014 if (IS_ERR(oplockThread)) {
1015 rc = PTR_ERR(oplockThread);
Steve French6dc0f872007-07-06 23:13:06 +00001016 cERROR(1, ("error %d create oplock thread", rc));
Steve French45af7a02006-04-21 22:52:25 +00001017 goto out_unregister_filesystem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 }
Steve French45af7a02006-04-21 22:52:25 +00001019
1020 dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
1021 if (IS_ERR(dnotifyThread)) {
1022 rc = PTR_ERR(dnotifyThread);
Steve French6dc0f872007-07-06 23:13:06 +00001023 cERROR(1, ("error %d create dnotify thread", rc));
Steve French45af7a02006-04-21 22:52:25 +00001024 goto out_stop_oplock_thread;
1025 }
1026
1027 return 0;
1028
1029 out_stop_oplock_thread:
1030 kthread_stop(oplockThread);
1031 out_unregister_filesystem:
1032 unregister_filesystem(&cifs_fs_type);
1033 out_destroy_request_bufs:
1034 cifs_destroy_request_bufs();
1035 out_destroy_mids:
1036 cifs_destroy_mids();
1037 out_destroy_inodecache:
1038 cifs_destroy_inodecache();
1039 out_clean_proc:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040#ifdef CONFIG_PROC_FS
1041 cifs_proc_clean();
1042#endif
1043 return rc;
1044}
1045
1046static void __exit
1047exit_cifs(void)
1048{
Steve French63135e02007-07-17 17:34:02 +00001049 cFYI(0, ("exit_cifs"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050#ifdef CONFIG_PROC_FS
1051 cifs_proc_clean();
1052#endif
1053 unregister_filesystem(&cifs_fs_type);
1054 cifs_destroy_inodecache();
1055 cifs_destroy_mids();
1056 cifs_destroy_request_bufs();
Steve French45af7a02006-04-21 22:52:25 +00001057 kthread_stop(oplockThread);
1058 kthread_stop(dnotifyThread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059}
1060
1061MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
Steve French6dc0f872007-07-06 23:13:06 +00001062MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063MODULE_DESCRIPTION
Steve French63135e02007-07-17 17:34:02 +00001064 ("VFS to access servers complying with the SNIA CIFS Specification "
1065 "e.g. Samba and Windows");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066MODULE_VERSION(CIFS_VERSION);
1067module_init(init_cifs)
1068module_exit(exit_cifs)