blob: 39c2cbdface7b52e27ef8f79820caa6e1d350eff [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>
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;
Igor Mammedove6ab1582008-01-11 01:49:48 +0000100#ifdef CONFIG_CIFS_DFS_UPCALL
101 int len;
102#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +0000104
Steve French1b2b2122007-02-17 04:30:54 +0000105 /* BB should we make this contingent on mount parm? */
106 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
Steve French790fe572007-07-07 19:25:05 +0000107 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 cifs_sb = CIFS_SB(sb);
Steve French4523cc32007-04-30 20:13:06 +0000109 if (cifs_sb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
Igor Mammedove6ab1582008-01-11 01:49:48 +0000112#ifdef CONFIG_CIFS_DFS_UPCALL
113 /* copy mount params to sb for use in submounts */
114 /* BB: should we move this after the mount so we
115 * do not have to do the copy on failed mounts?
116 * BB: May be it is better to do simple copy before
117 * complex operation (mount), and in case of fail
118 * just exit instead of doing mount and attempting
119 * undo it if this copy fails?*/
120 len = strlen(data);
121 cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
122 if (cifs_sb->mountdata == NULL) {
123 kfree(sb->s_fs_info);
124 sb->s_fs_info = NULL;
125 return -ENOMEM;
126 }
127 strncpy(cifs_sb->mountdata, data, len + 1);
128 cifs_sb->mountdata[len] = '\0';
129#endif
130
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 rc = cifs_mount(sb, cifs_sb, data, devname);
132
133 if (rc) {
134 if (!silent)
135 cERROR(1,
136 ("cifs_mount failed w/return code = %d", rc));
137 goto out_mount_failed;
138 }
139
140 sb->s_magic = CIFS_MAGIC_NUMBER;
141 sb->s_op = &cifs_super_ops;
Steve French4523cc32007-04-30 20:13:06 +0000142/* if (cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
Steve French790fe572007-07-07 19:25:05 +0000143 sb->s_blocksize =
144 cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145#ifdef CONFIG_CIFS_QUOTA
146 sb->s_qcop = &cifs_quotactl_ops;
147#endif
148 sb->s_blocksize = CIFS_MAX_MSGSIZE;
149 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
David Howellsce634ab2008-02-07 00:15:33 -0800150 inode = cifs_iget(sb, ROOT_I);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
David Howellsce634ab2008-02-07 00:15:33 -0800152 if (IS_ERR(inode)) {
153 rc = PTR_ERR(inode);
154 inode = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 goto out_no_root;
156 }
157
158 sb->s_root = d_alloc_root(inode);
159
160 if (!sb->s_root) {
161 rc = -ENOMEM;
162 goto out_no_root;
163 }
Steve French50c2f752007-07-13 00:33:32 +0000164
Steve French7521a3c2007-07-11 18:30:34 +0000165#ifdef CONFIG_CIFS_EXPERIMENTAL
166 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
167 cFYI(1, ("export ops supported"));
168 sb->s_export_op = &cifs_export_ops;
169 }
170#endif /* EXPERIMENTAL */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171
172 return 0;
173
174out_no_root:
175 cERROR(1, ("cifs_read_super: get root inode failed"));
176 if (inode)
177 iput(inode);
178
179out_mount_failed:
Steve French4523cc32007-04-30 20:13:06 +0000180 if (cifs_sb) {
Igor Mammedove6ab1582008-01-11 01:49:48 +0000181#ifdef CONFIG_CIFS_DFS_UPCALL
182 if (cifs_sb->mountdata) {
183 kfree(cifs_sb->mountdata);
184 cifs_sb->mountdata = NULL;
185 }
186#endif
Steve French4523cc32007-04-30 20:13:06 +0000187 if (cifs_sb->local_nls)
Steve French50c2f752007-07-13 00:33:32 +0000188 unload_nls(cifs_sb->local_nls);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 kfree(cifs_sb);
190 }
191 return rc;
192}
193
194static void
195cifs_put_super(struct super_block *sb)
196{
197 int rc = 0;
198 struct cifs_sb_info *cifs_sb;
199
200 cFYI(1, ("In cifs_put_super"));
201 cifs_sb = CIFS_SB(sb);
Steve French4523cc32007-04-30 20:13:06 +0000202 if (cifs_sb == NULL) {
Steve French790fe572007-07-07 19:25:05 +0000203 cFYI(1, ("Empty cifs superblock info passed to unmount"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 return;
205 }
Steve French790fe572007-07-07 19:25:05 +0000206 rc = cifs_umount(sb, cifs_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +0000207 if (rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 cERROR(1, ("cifs_umount failed with return code %d", rc));
Igor Mammedove6ab1582008-01-11 01:49:48 +0000209#ifdef CONFIG_CIFS_DFS_UPCALL
210 if (cifs_sb->mountdata) {
211 kfree(cifs_sb->mountdata);
212 cifs_sb->mountdata = NULL;
213 }
214#endif
215
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 unload_nls(cifs_sb->local_nls);
217 kfree(cifs_sb);
218 return;
219}
220
221static int
David Howells726c3342006-06-23 02:02:58 -0700222cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223{
David Howells726c3342006-06-23 02:02:58 -0700224 struct super_block *sb = dentry->d_sb;
Steve French790fe572007-07-07 19:25:05 +0000225 int xid;
Steve Frenchc81156d2005-04-28 22:41:07 -0700226 int rc = -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 struct cifs_sb_info *cifs_sb;
228 struct cifsTconInfo *pTcon;
229
230 xid = GetXid();
231
232 cifs_sb = CIFS_SB(sb);
233 pTcon = cifs_sb->tcon;
234
235 buf->f_type = CIFS_MAGIC_NUMBER;
236
237 /* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */
Steve French790fe572007-07-07 19:25:05 +0000238 buf->f_namelen = PATH_MAX; /* PATH_MAX may be too long - it would
Steve Frenchc81156d2005-04-28 22:41:07 -0700239 presumably be total path, but note
240 that some servers (includinng Samba 3)
241 have a shorter maximum path */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 buf->f_files = 0; /* undefined */
243 buf->f_ffree = 0; /* unlimited */
244
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245/* BB we could add a second check for a QFS Unix capability bit */
Steve Frenchf28ac912005-04-28 22:41:07 -0700246/* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */
Steve Frenchc81156d2005-04-28 22:41:07 -0700247 if ((pTcon->ses->capabilities & CAP_UNIX) && (CIFS_POSIX_EXTENSIONS &
248 le64_to_cpu(pTcon->fsUnixInfo.Capability)))
Steve French737b7582005-04-28 22:41:06 -0700249 rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
251 /* Only need to call the old QFSInfo if failed
252 on newer one */
Steve French4523cc32007-04-30 20:13:06 +0000253 if (rc)
254 if (pTcon->ses->capabilities & CAP_NT_SMBS)
Steve French9ac00b72006-09-30 04:13:17 +0000255 rc = CIFSSMBQFSInfo(xid, pTcon, buf); /* not supported by OS2 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
Steve French9ac00b72006-09-30 04:13:17 +0000257 /* Some old Windows servers also do not support level 103, retry with
258 older level one if old server failed the previous call or we
259 bypassed it because we detected that this was an older LANMAN sess */
Steve French4523cc32007-04-30 20:13:06 +0000260 if (rc)
Steve French20962432005-09-21 22:05:57 -0700261 rc = SMBOldQFSInfo(xid, pTcon, buf);
Steve French790fe572007-07-07 19:25:05 +0000262 /* int f_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 __fsid_t f_fsid;
264 int f_namelen; */
Steve Frenchc81156d2005-04-28 22:41:07 -0700265 /* BB get from info in tcon struct at mount time call to QFSAttrInfo */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 FreeXid(xid);
Steve Frenchc81156d2005-04-28 22:41:07 -0700267 return 0; /* always return success? what if volume is no
268 longer available? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269}
270
Steve French50c2f752007-07-13 00:33:32 +0000271static int cifs_permission(struct inode *inode, int mask, struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272{
273 struct cifs_sb_info *cifs_sb;
274
275 cifs_sb = CIFS_SB(inode->i_sb);
276
Steve French26f57362007-08-30 22:09:15 +0000277 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 return 0;
Steve French26f57362007-08-30 22:09:15 +0000279 else /* file mode might have been restricted at mount time
Steve French50c2f752007-07-13 00:33:32 +0000280 on the client (above and beyond ACL on servers) for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 servers which do not support setting and viewing mode bits,
Steve French50c2f752007-07-13 00:33:32 +0000282 so allowing client to check permissions is useful */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 return generic_permission(inode, mask, NULL);
284}
285
Christoph Lametere18b8902006-12-06 20:33:20 -0800286static struct kmem_cache *cifs_inode_cachep;
287static struct kmem_cache *cifs_req_cachep;
288static struct kmem_cache *cifs_mid_cachep;
289struct kmem_cache *cifs_oplock_cachep;
290static struct kmem_cache *cifs_sm_req_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291mempool_t *cifs_sm_req_poolp;
292mempool_t *cifs_req_poolp;
293mempool_t *cifs_mid_poolp;
294
295static struct inode *
296cifs_alloc_inode(struct super_block *sb)
297{
298 struct cifsInodeInfo *cifs_inode;
Christoph Lametere94b1762006-12-06 20:33:17 -0800299 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 if (!cifs_inode)
301 return NULL;
302 cifs_inode->cifsAttrs = 0x20; /* default */
303 atomic_set(&cifs_inode->inUse, 0);
304 cifs_inode->time = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +0000305 cifs_inode->write_behind_rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 /* Until the file is open and we have gotten oplock
307 info back from the server, can not assume caching of
308 file data or metadata */
309 cifs_inode->clientCanCacheRead = FALSE;
310 cifs_inode->clientCanCacheAll = FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
Steve French50c2f752007-07-13 00:33:32 +0000312
Steve French1b2b2122007-02-17 04:30:54 +0000313 /* Can not set i_flags here - they get immediately overwritten
314 to zero by the VFS */
315/* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 INIT_LIST_HEAD(&cifs_inode->openFileList);
317 return &cifs_inode->vfs_inode;
318}
319
320static void
321cifs_destroy_inode(struct inode *inode)
322{
323 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
324}
325
326/*
327 * cifs_show_options() is for displaying mount options in /proc/mounts.
328 * Not all settable options are displayed but most of the important
329 * ones are.
330 */
331static int
332cifs_show_options(struct seq_file *s, struct vfsmount *m)
333{
334 struct cifs_sb_info *cifs_sb;
335
336 cifs_sb = CIFS_SB(m->mnt_sb);
337
338 if (cifs_sb) {
339 if (cifs_sb->tcon) {
Steve French004c46b2007-02-17 04:34:13 +0000340/* BB add prepath to mount options displayed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
342 if (cifs_sb->tcon->ses) {
343 if (cifs_sb->tcon->ses->userName)
344 seq_printf(s, ",username=%s",
345 cifs_sb->tcon->ses->userName);
Steve French4523cc32007-04-30 20:13:06 +0000346 if (cifs_sb->tcon->ses->domainName)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 seq_printf(s, ",domain=%s",
348 cifs_sb->tcon->ses->domainName);
349 }
Steve Frenchd5d18502007-10-17 21:31:52 +0000350 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) ||
351 !(cifs_sb->tcon->unix_ext))
352 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
353 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) ||
354 !(cifs_sb->tcon->unix_ext))
355 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 }
Steve French4523cc32007-04-30 20:13:06 +0000357 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
358 seq_printf(s, ",posixpaths");
Steve French50c2f752007-07-13 00:33:32 +0000359 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
360 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 }
362 return 0;
363}
364
365#ifdef CONFIG_CIFS_QUOTA
Steve French50c2f752007-07-13 00:33:32 +0000366int cifs_xquota_set(struct super_block *sb, int quota_type, qid_t qid,
367 struct fs_disk_quota *pdquota)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368{
369 int xid;
370 int rc = 0;
371 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
372 struct cifsTconInfo *pTcon;
Steve French50c2f752007-07-13 00:33:32 +0000373
Steve French4523cc32007-04-30 20:13:06 +0000374 if (cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 pTcon = cifs_sb->tcon;
376 else
377 return -EIO;
378
379
380 xid = GetXid();
Steve French4523cc32007-04-30 20:13:06 +0000381 if (pTcon) {
Steve French50c2f752007-07-13 00:33:32 +0000382 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 } else {
Cyrill Gorcunov95ba7362007-08-24 00:23:36 +0000384 rc = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 }
386
387 FreeXid(xid);
388 return rc;
389}
390
Steve French50c2f752007-07-13 00:33:32 +0000391int cifs_xquota_get(struct super_block *sb, int quota_type, qid_t qid,
392 struct fs_disk_quota *pdquota)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393{
394 int xid;
395 int rc = 0;
396 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
397 struct cifsTconInfo *pTcon;
398
Steve French4523cc32007-04-30 20:13:06 +0000399 if (cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 pTcon = cifs_sb->tcon;
401 else
402 return -EIO;
403
404 xid = GetXid();
Steve French4523cc32007-04-30 20:13:06 +0000405 if (pTcon) {
Steve French50c2f752007-07-13 00:33:32 +0000406 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 } else {
408 rc = -EIO;
409 }
410
411 FreeXid(xid);
412 return rc;
413}
414
Steve French50c2f752007-07-13 00:33:32 +0000415int cifs_xstate_set(struct super_block *sb, unsigned int flags, int operation)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416{
Steve French50c2f752007-07-13 00:33:32 +0000417 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 int rc = 0;
419 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
420 struct cifsTconInfo *pTcon;
421
Steve French4523cc32007-04-30 20:13:06 +0000422 if (cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 pTcon = cifs_sb->tcon;
424 else
425 return -EIO;
426
427 xid = GetXid();
Steve French4523cc32007-04-30 20:13:06 +0000428 if (pTcon) {
Steve French50c2f752007-07-13 00:33:32 +0000429 cFYI(1, ("flags: 0x%x operation: 0x%x", flags, operation));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 } else {
431 rc = -EIO;
432 }
433
434 FreeXid(xid);
435 return rc;
436}
437
Steve French50c2f752007-07-13 00:33:32 +0000438int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439{
440 int xid;
441 int rc = 0;
442 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
443 struct cifsTconInfo *pTcon;
444
Steve French4523cc32007-04-30 20:13:06 +0000445 if (cifs_sb) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 pTcon = cifs_sb->tcon;
447 } else {
448 return -EIO;
449 }
450 xid = GetXid();
Steve French4523cc32007-04-30 20:13:06 +0000451 if (pTcon) {
Steve French50c2f752007-07-13 00:33:32 +0000452 cFYI(1, ("pqstats %p", qstats));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 } else {
454 rc = -EIO;
455 }
456
457 FreeXid(xid);
458 return rc;
459}
460
461static struct quotactl_ops cifs_quotactl_ops = {
462 .set_xquota = cifs_xquota_set,
Roel Kluin6f7e8f32008-02-12 20:38:10 +0000463 .get_xquota = cifs_xquota_get,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 .set_xstate = cifs_xstate_set,
465 .get_xstate = cifs_xstate_get,
466};
467#endif
468
Al Viro42faad92008-04-24 07:21:56 -0400469static void cifs_umount_begin(struct super_block *sb)
Steve French68058e72005-10-10 10:34:22 -0700470{
Al Viro42faad92008-04-24 07:21:56 -0400471 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French50c2f752007-07-13 00:33:32 +0000472 struct cifsTconInfo *tcon;
Steve French68058e72005-10-10 10:34:22 -0700473
Steve French4523cc32007-04-30 20:13:06 +0000474 if (cifs_sb == NULL)
Steve French9e2e85f2005-10-10 14:28:38 -0700475 return;
476
477 tcon = cifs_sb->tcon;
Steve French4523cc32007-04-30 20:13:06 +0000478 if (tcon == NULL)
Steve French9e2e85f2005-10-10 14:28:38 -0700479 return;
Steve French5e1253b2005-10-10 14:06:37 -0700480 down(&tcon->tconSem);
481 if (atomic_read(&tcon->useCount) == 1)
482 tcon->tidStatus = CifsExiting;
483 up(&tcon->tconSem);
484
Steve French3a5ff612006-07-14 22:37:11 +0000485 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
Steve French7b7abfe2005-11-09 15:21:09 -0800486 /* cancel_notify_requests(tcon); */
Steve French50c2f752007-07-13 00:33:32 +0000487 if (tcon->ses && tcon->ses->server) {
488 cFYI(1, ("wake up tasks now - umount begin not complete"));
Steve French9e2e85f2005-10-10 14:28:38 -0700489 wake_up_all(&tcon->ses->server->request_q);
Steve French6ab16d22005-11-29 20:55:11 -0800490 wake_up_all(&tcon->ses->server->response_q);
491 msleep(1); /* yield */
492 /* we have to kick the requests once more */
493 wake_up_all(&tcon->ses->server->response_q);
494 msleep(1);
Steve French5e1253b2005-10-10 14:06:37 -0700495 }
496/* BB FIXME - finish add checks for tidStatus BB */
Steve French68058e72005-10-10 10:34:22 -0700497
498 return;
499}
Steve French68058e72005-10-10 10:34:22 -0700500
Steve Frenchbf97d282006-09-28 21:34:06 +0000501#ifdef CONFIG_CIFS_STATS2
502static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
503{
504 /* BB FIXME */
505 return 0;
506}
507#endif
508
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509static int cifs_remount(struct super_block *sb, int *flags, char *data)
510{
511 *flags |= MS_NODIRATIME;
512 return 0;
513}
514
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800515static const struct super_operations cifs_super_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 .put_super = cifs_put_super,
517 .statfs = cifs_statfs,
518 .alloc_inode = cifs_alloc_inode,
519 .destroy_inode = cifs_destroy_inode,
Steve French50c2f752007-07-13 00:33:32 +0000520/* .drop_inode = generic_delete_inode,
521 .delete_inode = cifs_delete_inode, */ /* Do not need above two
522 functions unless later we add lazy close of inodes or unless the
523 kernel forgets to call us with the same number of releases (closes)
524 as opens */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 .show_options = cifs_show_options,
Steve French7b7abfe2005-11-09 15:21:09 -0800526 .umount_begin = cifs_umount_begin,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 .remount_fs = cifs_remount,
Steve Frenchbf97d282006-09-28 21:34:06 +0000528#ifdef CONFIG_CIFS_STATS2
Steve Frenchf46d3e12006-09-30 01:08:55 +0000529 .show_stats = cifs_show_stats,
Steve Frenchbf97d282006-09-28 21:34:06 +0000530#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531};
532
David Howells454e2392006-06-23 02:02:57 -0700533static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534cifs_get_sb(struct file_system_type *fs_type,
David Howells454e2392006-06-23 02:02:57 -0700535 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536{
537 int rc;
538 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
539
540 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
541
542 if (IS_ERR(sb))
David Howells454e2392006-06-23 02:02:57 -0700543 return PTR_ERR(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
545 sb->s_flags = flags;
546
Theodore Ts'o9b04c992006-03-24 03:15:10 -0800547 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 if (rc) {
549 up_write(&sb->s_umount);
550 deactivate_super(sb);
David Howells454e2392006-06-23 02:02:57 -0700551 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 }
553 sb->s_flags |= MS_ACTIVE;
David Howells454e2392006-06-23 02:02:57 -0700554 return simple_set_mnt(mnt, sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555}
556
Badari Pulavarty027445c2006-09-30 23:28:46 -0700557static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
558 unsigned long nr_segs, loff_t pos)
Steve French87c89dd2005-11-17 17:03:00 -0800559{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800560 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
Steve French87c89dd2005-11-17 17:03:00 -0800561 ssize_t written;
562
Badari Pulavarty027445c2006-09-30 23:28:46 -0700563 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
Steve French87c89dd2005-11-17 17:03:00 -0800564 if (!CIFS_I(inode)->clientCanCacheAll)
565 filemap_fdatawrite(inode->i_mapping);
566 return written;
567}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
Steve Frenchc32a0b62006-01-12 14:41:28 -0800569static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
570{
571 /* origin == SEEK_END => we must revalidate the cached file length */
Steve French0889a942006-09-23 22:11:07 +0000572 if (origin == SEEK_END) {
Steve French030e9d82007-02-01 04:27:59 +0000573 int retval;
574
575 /* some applications poll for the file length in this strange
576 way so we must seek to end on non-oplocked files by
577 setting the revalidate time to zero */
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000578 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
Steve French030e9d82007-02-01 04:27:59 +0000579
580 retval = cifs_revalidate(file->f_path.dentry);
Steve Frenchc32a0b62006-01-12 14:41:28 -0800581 if (retval < 0)
582 return (loff_t)retval;
583 }
584 return remote_llseek(file, offset, origin);
585}
586
Igor Mammedove6ab1582008-01-11 01:49:48 +0000587struct file_system_type cifs_fs_type = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 .owner = THIS_MODULE,
589 .name = "cifs",
590 .get_sb = cifs_get_sb,
591 .kill_sb = kill_anon_super,
592 /* .fs_flags */
593};
Arjan van de Ven754661f2007-02-12 00:55:38 -0800594const struct inode_operations cifs_dir_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 .create = cifs_create,
596 .lookup = cifs_lookup,
597 .getattr = cifs_getattr,
598 .unlink = cifs_unlink,
599 .link = cifs_hardlink,
600 .mkdir = cifs_mkdir,
601 .rmdir = cifs_rmdir,
602 .rename = cifs_rename,
603 .permission = cifs_permission,
604/* revalidate:cifs_revalidate, */
605 .setattr = cifs_setattr,
606 .symlink = cifs_symlink,
607 .mknod = cifs_mknod,
608#ifdef CONFIG_CIFS_XATTR
609 .setxattr = cifs_setxattr,
610 .getxattr = cifs_getxattr,
611 .listxattr = cifs_listxattr,
612 .removexattr = cifs_removexattr,
613#endif
614};
615
Arjan van de Ven754661f2007-02-12 00:55:38 -0800616const struct inode_operations cifs_file_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617/* revalidate:cifs_revalidate, */
618 .setattr = cifs_setattr,
619 .getattr = cifs_getattr, /* do we need this anymore? */
620 .rename = cifs_rename,
621 .permission = cifs_permission,
622#ifdef CONFIG_CIFS_XATTR
623 .setxattr = cifs_setxattr,
624 .getxattr = cifs_getxattr,
625 .listxattr = cifs_listxattr,
626 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000627#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628};
629
Arjan van de Ven754661f2007-02-12 00:55:38 -0800630const struct inode_operations cifs_symlink_inode_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000631 .readlink = generic_readlink,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 .follow_link = cifs_follow_link,
633 .put_link = cifs_put_link,
634 .permission = cifs_permission,
635 /* BB add the following two eventually */
636 /* revalidate: cifs_revalidate,
637 setattr: cifs_notify_change, *//* BB do we need notify change */
638#ifdef CONFIG_CIFS_XATTR
639 .setxattr = cifs_setxattr,
640 .getxattr = cifs_getxattr,
641 .listxattr = cifs_listxattr,
642 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000643#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644};
645
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800646const struct file_operations cifs_file_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800647 .read = do_sync_read,
648 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800649 .aio_read = generic_file_aio_read,
650 .aio_write = cifs_file_aio_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 .open = cifs_open,
652 .release = cifs_close,
653 .lock = cifs_lock,
654 .fsync = cifs_fsync,
655 .flush = cifs_flush,
656 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200657 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800658 .llseek = cifs_llseek,
Steve Frenchc67593a2005-04-28 22:41:04 -0700659#ifdef CONFIG_CIFS_POSIX
660 .ioctl = cifs_ioctl,
661#endif /* CONFIG_CIFS_POSIX */
662
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663#ifdef CONFIG_CIFS_EXPERIMENTAL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 .dir_notify = cifs_dir_notify,
665#endif /* CONFIG_CIFS_EXPERIMENTAL */
666};
667
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800668const struct file_operations cifs_file_direct_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000669 /* no mmap, no aio, no readv -
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 BB reevaluate whether they can be done with directio, no cache */
671 .read = cifs_user_read,
672 .write = cifs_user_write,
673 .open = cifs_open,
674 .release = cifs_close,
675 .lock = cifs_lock,
676 .fsync = cifs_fsync,
677 .flush = cifs_flush,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200678 .splice_read = generic_file_splice_read,
Steve Frenchc67593a2005-04-28 22:41:04 -0700679#ifdef CONFIG_CIFS_POSIX
680 .ioctl = cifs_ioctl,
681#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800682 .llseek = cifs_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683#ifdef CONFIG_CIFS_EXPERIMENTAL
684 .dir_notify = cifs_dir_notify,
685#endif /* CONFIG_CIFS_EXPERIMENTAL */
686};
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800687const struct file_operations cifs_file_nobrl_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800688 .read = do_sync_read,
689 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800690 .aio_read = generic_file_aio_read,
691 .aio_write = cifs_file_aio_write,
692 .open = cifs_open,
693 .release = cifs_close,
694 .fsync = cifs_fsync,
695 .flush = cifs_flush,
696 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200697 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800698 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800699#ifdef CONFIG_CIFS_POSIX
Steve French87c89dd2005-11-17 17:03:00 -0800700 .ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800701#endif /* CONFIG_CIFS_POSIX */
702
703#ifdef CONFIG_CIFS_EXPERIMENTAL
Steve French87c89dd2005-11-17 17:03:00 -0800704 .dir_notify = cifs_dir_notify,
Steve French8b94bcb2005-11-11 11:41:00 -0800705#endif /* CONFIG_CIFS_EXPERIMENTAL */
706};
707
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800708const struct file_operations cifs_file_direct_nobrl_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000709 /* no mmap, no aio, no readv -
Steve French87c89dd2005-11-17 17:03:00 -0800710 BB reevaluate whether they can be done with directio, no cache */
711 .read = cifs_user_read,
712 .write = cifs_user_write,
713 .open = cifs_open,
714 .release = cifs_close,
715 .fsync = cifs_fsync,
716 .flush = cifs_flush,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200717 .splice_read = generic_file_splice_read,
Steve French8b94bcb2005-11-11 11:41:00 -0800718#ifdef CONFIG_CIFS_POSIX
Steve French87c89dd2005-11-17 17:03:00 -0800719 .ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800720#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800721 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800722#ifdef CONFIG_CIFS_EXPERIMENTAL
Steve French87c89dd2005-11-17 17:03:00 -0800723 .dir_notify = cifs_dir_notify,
Steve French8b94bcb2005-11-11 11:41:00 -0800724#endif /* CONFIG_CIFS_EXPERIMENTAL */
725};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800727const struct file_operations cifs_dir_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 .readdir = cifs_readdir,
729 .release = cifs_closedir,
730 .read = generic_read_dir,
731#ifdef CONFIG_CIFS_EXPERIMENTAL
732 .dir_notify = cifs_dir_notify,
733#endif /* CONFIG_CIFS_EXPERIMENTAL */
Steve French50c2f752007-07-13 00:33:32 +0000734 .ioctl = cifs_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735};
736
737static void
Christoph Lameter4ba9b9d2007-10-16 23:25:51 -0700738cifs_init_once(struct kmem_cache *cachep, void *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739{
740 struct cifsInodeInfo *cifsi = inode;
741
Christoph Lametera35afb82007-05-16 22:10:57 -0700742 inode_init_once(&cifsi->vfs_inode);
743 INIT_LIST_HEAD(&cifsi->lockList);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744}
745
746static int
747cifs_init_inodecache(void)
748{
749 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
Steve French26f57362007-08-30 22:09:15 +0000750 sizeof(struct cifsInodeInfo),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800751 0, (SLAB_RECLAIM_ACCOUNT|
752 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +0900753 cifs_init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 if (cifs_inode_cachep == NULL)
755 return -ENOMEM;
756
757 return 0;
758}
759
760static void
761cifs_destroy_inodecache(void)
762{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700763 kmem_cache_destroy(cifs_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764}
765
766static int
767cifs_init_request_bufs(void)
768{
Steve French4523cc32007-04-30 20:13:06 +0000769 if (CIFSMaxBufSize < 8192) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
771 Unicode path name has to fit in any SMB/CIFS path based frames */
772 CIFSMaxBufSize = 8192;
773 } else if (CIFSMaxBufSize > 1024*127) {
774 CIFSMaxBufSize = 1024 * 127;
775 } else {
776 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
777 }
778/* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
779 cifs_req_cachep = kmem_cache_create("cifs_request",
780 CIFSMaxBufSize +
781 MAX_CIFS_HDR_SIZE, 0,
Paul Mundt20c2df82007-07-20 10:11:58 +0900782 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 if (cifs_req_cachep == NULL)
784 return -ENOMEM;
785
Steve French4523cc32007-04-30 20:13:06 +0000786 if (cifs_min_rcv < 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 cifs_min_rcv = 1;
788 else if (cifs_min_rcv > 64) {
789 cifs_min_rcv = 64;
Steve French50c2f752007-07-13 00:33:32 +0000790 cERROR(1, ("cifs_min_rcv set to maximum (64)"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 }
792
Matthew Dobson93d23412006-03-26 01:37:50 -0800793 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
794 cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795
Steve French4523cc32007-04-30 20:13:06 +0000796 if (cifs_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 kmem_cache_destroy(cifs_req_cachep);
798 return -ENOMEM;
799 }
Steve Frenchec637e32005-12-12 20:53:18 -0800800 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 almost all handle based requests (but not write response, nor is it
802 sufficient for path based requests). A smaller size would have
Steve French50c2f752007-07-13 00:33:32 +0000803 been more efficient (compacting multiple slab items on one 4k page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 for the case in which debug was on, but this larger size allows
805 more SMBs to use small buffer alloc and is still much more
Steve French6dc0f872007-07-06 23:13:06 +0000806 efficient to alloc 1 per page off the slab compared to 17K (5page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 alloc of large cifs buffers even when page debugging is on */
808 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
Steve French6dc0f872007-07-06 23:13:06 +0000809 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +0900810 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 if (cifs_sm_req_cachep == NULL) {
812 mempool_destroy(cifs_req_poolp);
813 kmem_cache_destroy(cifs_req_cachep);
Steve French6dc0f872007-07-06 23:13:06 +0000814 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 }
816
Steve French4523cc32007-04-30 20:13:06 +0000817 if (cifs_min_small < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 cifs_min_small = 2;
819 else if (cifs_min_small > 256) {
820 cifs_min_small = 256;
Steve French6dc0f872007-07-06 23:13:06 +0000821 cFYI(1, ("cifs_min_small set to maximum (256)"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 }
823
Matthew Dobson93d23412006-03-26 01:37:50 -0800824 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
825 cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826
Steve French4523cc32007-04-30 20:13:06 +0000827 if (cifs_sm_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 mempool_destroy(cifs_req_poolp);
829 kmem_cache_destroy(cifs_req_cachep);
830 kmem_cache_destroy(cifs_sm_req_cachep);
831 return -ENOMEM;
832 }
833
834 return 0;
835}
836
837static void
838cifs_destroy_request_bufs(void)
839{
840 mempool_destroy(cifs_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700841 kmem_cache_destroy(cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 mempool_destroy(cifs_sm_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700843 kmem_cache_destroy(cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844}
845
846static int
847cifs_init_mids(void)
848{
849 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
Steve French26f57362007-08-30 22:09:15 +0000850 sizeof(struct mid_q_entry), 0,
851 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 if (cifs_mid_cachep == NULL)
853 return -ENOMEM;
854
Matthew Dobson93d23412006-03-26 01:37:50 -0800855 /* 3 is a reasonable minimum number of simultaneous operations */
856 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
Steve French4523cc32007-04-30 20:13:06 +0000857 if (cifs_mid_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 kmem_cache_destroy(cifs_mid_cachep);
859 return -ENOMEM;
860 }
861
862 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
Steve French26f57362007-08-30 22:09:15 +0000863 sizeof(struct oplock_q_entry), 0,
864 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 if (cifs_oplock_cachep == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 mempool_destroy(cifs_mid_poolp);
Akinobu Mitae6985c72007-06-04 16:14:59 +0000867 kmem_cache_destroy(cifs_mid_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 return -ENOMEM;
869 }
870
871 return 0;
872}
873
874static void
875cifs_destroy_mids(void)
876{
877 mempool_destroy(cifs_mid_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700878 kmem_cache_destroy(cifs_mid_cachep);
879 kmem_cache_destroy(cifs_oplock_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880}
881
Steve French50c2f752007-07-13 00:33:32 +0000882static int cifs_oplock_thread(void *dummyarg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883{
Steve French6dc0f872007-07-06 23:13:06 +0000884 struct oplock_q_entry *oplock_item;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 struct cifsTconInfo *pTcon;
Steve French6dc0f872007-07-06 23:13:06 +0000886 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 __u16 netfid;
Jeff Laytoncea21802007-11-20 23:19:03 +0000888 int rc, waitrc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700890 set_freezable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 do {
Steve French6dc0f872007-07-06 23:13:06 +0000892 if (try_to_freeze())
Steve Frenchede13272005-08-30 20:10:14 -0700893 continue;
Steve French50c2f752007-07-13 00:33:32 +0000894
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 spin_lock(&GlobalMid_Lock);
Steve French4523cc32007-04-30 20:13:06 +0000896 if (list_empty(&GlobalOplock_Q)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 spin_unlock(&GlobalMid_Lock);
898 set_current_state(TASK_INTERRUPTIBLE);
899 schedule_timeout(39*HZ);
900 } else {
Steve French6dc0f872007-07-06 23:13:06 +0000901 oplock_item = list_entry(GlobalOplock_Q.next,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 struct oplock_q_entry, qhead);
Steve French4523cc32007-04-30 20:13:06 +0000903 if (oplock_item) {
Steve French50c2f752007-07-13 00:33:32 +0000904 cFYI(1, ("found oplock item to write out"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 pTcon = oplock_item->tcon;
906 inode = oplock_item->pinode;
907 netfid = oplock_item->netfid;
908 spin_unlock(&GlobalMid_Lock);
909 DeleteOplockQEntry(oplock_item);
910 /* can not grab inode sem here since it would
Steve French6dc0f872007-07-06 23:13:06 +0000911 deadlock when oplock received on delete
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800912 since vfs_unlink holds the i_mutex across
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 the call */
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800914 /* mutex_lock(&inode->i_mutex);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 if (S_ISREG(inode->i_mode)) {
Steve French26f57362007-08-30 22:09:15 +0000916 rc =
917 filemap_fdatawrite(inode->i_mapping);
Steve French50c2f752007-07-13 00:33:32 +0000918 if (CIFS_I(inode)->clientCanCacheRead
919 == 0) {
Jeff Laytoncea21802007-11-20 23:19:03 +0000920 waitrc = filemap_fdatawait(inode->i_mapping);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 invalidate_remote_inode(inode);
922 }
Jeff Laytoncea21802007-11-20 23:19:03 +0000923 if (rc == 0)
924 rc = waitrc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 } else
926 rc = 0;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800927 /* mutex_unlock(&inode->i_mutex);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 if (rc)
929 CIFS_I(inode)->write_behind_rc = rc;
Steve French6dc0f872007-07-06 23:13:06 +0000930 cFYI(1, ("Oplock flush inode %p rc %d",
931 inode, rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932
Steve French6dc0f872007-07-06 23:13:06 +0000933 /* releasing stale oplock after recent reconnect
934 of smb session using a now incorrect file
935 handle is not a data integrity issue but do
936 not bother sending an oplock release if session
937 to server still is disconnected since oplock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 already released by the server in that case */
Steve French4523cc32007-04-30 20:13:06 +0000939 if (pTcon->tidStatus != CifsNeedReconnect) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 rc = CIFSSMBLock(0, pTcon, netfid,
Steve French6dc0f872007-07-06 23:13:06 +0000941 0 /* len */ , 0 /* offset */, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 0, LOCKING_ANDX_OPLOCK_RELEASE,
943 0 /* wait flag */);
Steve French26f57362007-08-30 22:09:15 +0000944 cFYI(1, ("Oplock release rc = %d", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 }
946 } else
947 spin_unlock(&GlobalMid_Lock);
Steve French68058e72005-10-10 10:34:22 -0700948 set_current_state(TASK_INTERRUPTIBLE);
949 schedule_timeout(1); /* yield in case q were corrupt */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 }
Steve French45af7a02006-04-21 22:52:25 +0000951 } while (!kthread_should_stop());
952
953 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954}
955
Steve French50c2f752007-07-13 00:33:32 +0000956static int cifs_dnotify_thread(void *dummyarg)
Steve French8d0d5092005-08-18 09:41:43 -0700957{
Steve French6ab16d22005-11-29 20:55:11 -0800958 struct list_head *tmp;
959 struct cifsSesInfo *ses;
960
Steve French8d0d5092005-08-18 09:41:43 -0700961 do {
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000962 if (try_to_freeze())
Steve French16abbec2005-08-30 13:10:14 -0700963 continue;
Steve French8d0d5092005-08-18 09:41:43 -0700964 set_current_state(TASK_INTERRUPTIBLE);
Steve French6ab16d22005-11-29 20:55:11 -0800965 schedule_timeout(15*HZ);
966 read_lock(&GlobalSMBSeslock);
967 /* check if any stuck requests that need
968 to be woken up and wakeq so the
969 thread can wake up and error out */
970 list_for_each(tmp, &GlobalSMBSessionList) {
Steve French6dc0f872007-07-06 23:13:06 +0000971 ses = list_entry(tmp, struct cifsSesInfo,
Steve French6ab16d22005-11-29 20:55:11 -0800972 cifsSessionList);
Steve French6dc0f872007-07-06 23:13:06 +0000973 if (ses && ses->server &&
Steve French2a138ebb2005-11-29 21:22:19 -0800974 atomic_read(&ses->server->inFlight))
Steve French6ab16d22005-11-29 20:55:11 -0800975 wake_up_all(&ses->server->response_q);
976 }
977 read_unlock(&GlobalSMBSeslock);
Steve French45af7a02006-04-21 22:52:25 +0000978 } while (!kthread_should_stop());
979
980 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981}
982
983static int __init
984init_cifs(void)
985{
986 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 cifs_proc_init();
Steve French2cd646a2006-09-28 19:43:08 +0000988/* INIT_LIST_HEAD(&GlobalServerList);*/ /* BB not implemented yet */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 INIT_LIST_HEAD(&GlobalSMBSessionList);
990 INIT_LIST_HEAD(&GlobalTreeConnectionList);
991 INIT_LIST_HEAD(&GlobalOplock_Q);
Steve French4ca9c192005-10-10 19:52:13 -0700992#ifdef CONFIG_CIFS_EXPERIMENTAL
993 INIT_LIST_HEAD(&GlobalDnotifyReqList);
994 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
Steve French6dc0f872007-07-06 23:13:06 +0000995#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996/*
997 * Initialize Global counters
998 */
999 atomic_set(&sesInfoAllocCount, 0);
1000 atomic_set(&tconInfoAllocCount, 0);
Steve French6dc0f872007-07-06 23:13:06 +00001001 atomic_set(&tcpSesAllocCount, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 atomic_set(&tcpSesReconnectCount, 0);
1003 atomic_set(&tconInfoReconnectCount, 0);
1004
1005 atomic_set(&bufAllocCount, 0);
Steve French4498eed52005-12-03 13:58:57 -08001006 atomic_set(&smBufAllocCount, 0);
1007#ifdef CONFIG_CIFS_STATS2
1008 atomic_set(&totBufAllocCount, 0);
1009 atomic_set(&totSmBufAllocCount, 0);
1010#endif /* CONFIG_CIFS_STATS2 */
1011
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 atomic_set(&midCount, 0);
1013 GlobalCurrentXid = 0;
1014 GlobalTotalActiveXid = 0;
1015 GlobalMaxActiveXid = 0;
Steve French2cd646a2006-09-28 19:43:08 +00001016 memset(Local_System_Name, 0, 15);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 rwlock_init(&GlobalSMBSeslock);
1018 spin_lock_init(&GlobalMid_Lock);
1019
Steve French4523cc32007-04-30 20:13:06 +00001020 if (cifs_max_pending < 2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 cifs_max_pending = 2;
Steve French6dc0f872007-07-06 23:13:06 +00001022 cFYI(1, ("cifs_max_pending set to min of 2"));
Steve French4523cc32007-04-30 20:13:06 +00001023 } else if (cifs_max_pending > 256) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 cifs_max_pending = 256;
Steve French6dc0f872007-07-06 23:13:06 +00001025 cFYI(1, ("cifs_max_pending set to max of 256"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 }
1027
1028 rc = cifs_init_inodecache();
Steve French45af7a02006-04-21 22:52:25 +00001029 if (rc)
1030 goto out_clean_proc;
1031
1032 rc = cifs_init_mids();
1033 if (rc)
1034 goto out_destroy_inodecache;
1035
1036 rc = cifs_init_request_bufs();
1037 if (rc)
1038 goto out_destroy_mids;
1039
1040 rc = register_filesystem(&cifs_fs_type);
1041 if (rc)
1042 goto out_destroy_request_bufs;
Jeff Layton84a15b92007-11-03 05:02:24 +00001043#ifdef CONFIG_CIFS_UPCALL
1044 rc = register_key_type(&cifs_spnego_key_type);
1045 if (rc)
1046 goto out_unregister_filesystem;
1047#endif
Steve French61033352008-01-09 16:21:36 +00001048#ifdef CONFIG_CIFS_DFS_UPCALL
1049 rc = register_key_type(&key_type_dns_resolver);
1050 if (rc)
1051 goto out_unregister_key_type;
1052#endif
Steve French45af7a02006-04-21 22:52:25 +00001053 oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
1054 if (IS_ERR(oplockThread)) {
1055 rc = PTR_ERR(oplockThread);
Steve French6dc0f872007-07-06 23:13:06 +00001056 cERROR(1, ("error %d create oplock thread", rc));
Steve French61033352008-01-09 16:21:36 +00001057 goto out_unregister_dfs_key_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 }
Steve French45af7a02006-04-21 22:52:25 +00001059
1060 dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
1061 if (IS_ERR(dnotifyThread)) {
1062 rc = PTR_ERR(dnotifyThread);
Steve French6dc0f872007-07-06 23:13:06 +00001063 cERROR(1, ("error %d create dnotify thread", rc));
Steve French45af7a02006-04-21 22:52:25 +00001064 goto out_stop_oplock_thread;
1065 }
1066
1067 return 0;
1068
1069 out_stop_oplock_thread:
1070 kthread_stop(oplockThread);
Steve French61033352008-01-09 16:21:36 +00001071 out_unregister_dfs_key_type:
1072#ifdef CONFIG_CIFS_DFS_UPCALL
1073 unregister_key_type(&key_type_dns_resolver);
Jeff Layton84a15b92007-11-03 05:02:24 +00001074 out_unregister_key_type:
Steve French61033352008-01-09 16:21:36 +00001075#endif
Jeff Layton84a15b92007-11-03 05:02:24 +00001076#ifdef CONFIG_CIFS_UPCALL
1077 unregister_key_type(&cifs_spnego_key_type);
Steve French45af7a02006-04-21 22:52:25 +00001078 out_unregister_filesystem:
Jeff Layton84a15b92007-11-03 05:02:24 +00001079#endif
Steve French45af7a02006-04-21 22:52:25 +00001080 unregister_filesystem(&cifs_fs_type);
1081 out_destroy_request_bufs:
1082 cifs_destroy_request_bufs();
1083 out_destroy_mids:
1084 cifs_destroy_mids();
1085 out_destroy_inodecache:
1086 cifs_destroy_inodecache();
1087 out_clean_proc:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 cifs_proc_clean();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 return rc;
1090}
1091
1092static void __exit
1093exit_cifs(void)
1094{
Steve French90c81e02008-02-12 20:32:36 +00001095 cFYI(DBG2, ("exit_cifs"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 cifs_proc_clean();
Steve French61033352008-01-09 16:21:36 +00001097#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov78d31a32008-04-24 12:56:07 +04001098 cifs_dfs_release_automount_timer();
Steve French61033352008-01-09 16:21:36 +00001099 unregister_key_type(&key_type_dns_resolver);
1100#endif
Jeff Layton84a15b92007-11-03 05:02:24 +00001101#ifdef CONFIG_CIFS_UPCALL
1102 unregister_key_type(&cifs_spnego_key_type);
1103#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 unregister_filesystem(&cifs_fs_type);
1105 cifs_destroy_inodecache();
1106 cifs_destroy_mids();
1107 cifs_destroy_request_bufs();
Steve French45af7a02006-04-21 22:52:25 +00001108 kthread_stop(oplockThread);
1109 kthread_stop(dnotifyThread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110}
1111
1112MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
Steve French6dc0f872007-07-06 23:13:06 +00001113MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114MODULE_DESCRIPTION
Steve French63135e02007-07-17 17:34:02 +00001115 ("VFS to access servers complying with the SNIA CIFS Specification "
1116 "e.g. Samba and Windows");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117MODULE_VERSION(CIFS_VERSION);
1118module_init(init_cifs)
1119module_exit(exit_cifs)