blob: f50fc8728c94b68cd9f87b894bdf59ab795f6f53 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/cifsfs.c
3 *
Steve French2b280fa2008-05-17 03:12:45 +00004 * Copyright (C) International Business Machines Corp., 2002,2008
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * Common Internet FileSystem (CIFS) client
8 *
9 * This library is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU Lesser General Public License as published
11 * by the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24/* Note that BB means BUGBUG (ie something to fix eventually) */
25
26#include <linux/module.h>
27#include <linux/fs.h>
28#include <linux/mount.h>
29#include <linux/slab.h>
30#include <linux/init.h>
31#include <linux/list.h>
32#include <linux/seq_file.h>
33#include <linux/vfs.h>
34#include <linux/mempool.h>
Steve French6ab16d22005-11-29 20:55:11 -080035#include <linux/delay.h>
Steve French45af7a02006-04-21 22:52:25 +000036#include <linux/kthread.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080037#include <linux/freezer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include "cifsfs.h"
39#include "cifspdu.h"
40#define DECLARE_GLOBALS_HERE
41#include "cifsglob.h"
42#include "cifsproto.h"
43#include "cifs_debug.h"
44#include "cifs_fs_sb.h"
45#include <linux/mm.h>
Jeff Layton84a15b92007-11-03 05:02:24 +000046#include <linux/key-type.h>
Steve French61033352008-01-09 16:21:36 +000047#include "dns_resolve.h"
Jeff Laytone5459372007-11-03 05:11:06 +000048#include "cifs_spnego.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
50
51#ifdef CONFIG_CIFS_QUOTA
52static struct quotactl_ops cifs_quotactl_ops;
Steve French35c11fd2007-02-27 05:09:35 +000053#endif /* QUOTA */
54
Linus Torvalds1da177e2005-04-16 15:20:36 -070055int cifsFYI = 0;
56int cifsERROR = 1;
57int traceSMB = 0;
58unsigned int oplockEnabled = 1;
59unsigned int experimEnabled = 0;
60unsigned int linuxExtEnabled = 1;
61unsigned int lookupCacheEnabled = 1;
62unsigned int multiuser_mount = 0;
Steve French39798772006-05-31 22:40:51 +000063unsigned int extended_security = CIFSSEC_DEF;
64/* unsigned int ntlmv2_support = 0; */
Linus Torvalds1da177e2005-04-16 15:20:36 -070065unsigned int sign_CIFS_PDUs = 1;
Steve French6dc0f872007-07-06 23:13:06 +000066extern struct task_struct *oplockThread; /* remove sparse warning */
67struct task_struct *oplockThread = NULL;
Steve French99ee4db2007-02-27 05:35:17 +000068/* extern struct task_struct * dnotifyThread; remove sparse warning */
Steve French6dc0f872007-07-06 23:13:06 +000069static struct task_struct *dnotifyThread = NULL;
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -080070static const struct super_operations cifs_super_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070071unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
72module_param(CIFSMaxBufSize, int, 0);
Steve French63135e02007-07-17 17:34:02 +000073MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
74 "Default: 16384 Range: 8192 to 130048");
Linus Torvalds1da177e2005-04-16 15:20:36 -070075unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
76module_param(cifs_min_rcv, int, 0);
Steve French63135e02007-07-17 17:34:02 +000077MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
78 "1 to 64");
Linus Torvalds1da177e2005-04-16 15:20:36 -070079unsigned int cifs_min_small = 30;
80module_param(cifs_min_small, int, 0);
Steve French63135e02007-07-17 17:34:02 +000081MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
82 "Range: 2 to 256");
Linus Torvalds1da177e2005-04-16 15:20:36 -070083unsigned int cifs_max_pending = CIFS_MAX_REQ;
84module_param(cifs_max_pending, int, 0);
Steve French63135e02007-07-17 17:34:02 +000085MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
86 "Default: 50 Range: 2 to 256");
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
Linus Torvalds1da177e2005-04-16 15:20:36 -070088extern mempool_t *cifs_sm_req_poolp;
89extern mempool_t *cifs_req_poolp;
90extern mempool_t *cifs_mid_poolp;
91
Christoph Lametere18b8902006-12-06 20:33:20 -080092extern struct kmem_cache *cifs_oplock_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
94static int
95cifs_read_super(struct super_block *sb, void *data,
96 const char *devname, int silent)
97{
98 struct inode *inode;
99 struct cifs_sb_info *cifs_sb;
100 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +0000101
Steve French1b2b2122007-02-17 04:30:54 +0000102 /* BB should we make this contingent on mount parm? */
103 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
Steve French790fe572007-07-07 19:25:05 +0000104 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 cifs_sb = CIFS_SB(sb);
Steve French4523cc32007-04-30 20:13:06 +0000106 if (cifs_sb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108
Igor Mammedove6ab1582008-01-11 01:49:48 +0000109#ifdef CONFIG_CIFS_DFS_UPCALL
110 /* copy mount params to sb for use in submounts */
111 /* BB: should we move this after the mount so we
112 * do not have to do the copy on failed mounts?
113 * BB: May be it is better to do simple copy before
114 * complex operation (mount), and in case of fail
115 * just exit instead of doing mount and attempting
116 * undo it if this copy fails?*/
Steve French79ee9a82008-06-10 21:37:02 +0000117 if (data) {
118 int len = strlen(data);
119 cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
120 if (cifs_sb->mountdata == NULL) {
121 kfree(sb->s_fs_info);
122 sb->s_fs_info = NULL;
123 return -ENOMEM;
124 }
125 strncpy(cifs_sb->mountdata, data, len + 1);
126 cifs_sb->mountdata[len] = '\0';
Igor Mammedove6ab1582008-01-11 01:49:48 +0000127 }
Igor Mammedove6ab1582008-01-11 01:49:48 +0000128#endif
129
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 rc = cifs_mount(sb, cifs_sb, data, devname);
131
132 if (rc) {
133 if (!silent)
134 cERROR(1,
135 ("cifs_mount failed w/return code = %d", rc));
136 goto out_mount_failed;
137 }
138
139 sb->s_magic = CIFS_MAGIC_NUMBER;
140 sb->s_op = &cifs_super_ops;
Steve French4523cc32007-04-30 20:13:06 +0000141/* if (cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
Steve French790fe572007-07-07 19:25:05 +0000142 sb->s_blocksize =
143 cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144#ifdef CONFIG_CIFS_QUOTA
145 sb->s_qcop = &cifs_quotactl_ops;
146#endif
147 sb->s_blocksize = CIFS_MAX_MSGSIZE;
148 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
David Howellsce634ab2008-02-07 00:15:33 -0800149 inode = cifs_iget(sb, ROOT_I);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150
David Howellsce634ab2008-02-07 00:15:33 -0800151 if (IS_ERR(inode)) {
152 rc = PTR_ERR(inode);
153 inode = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 goto out_no_root;
155 }
156
157 sb->s_root = d_alloc_root(inode);
158
159 if (!sb->s_root) {
160 rc = -ENOMEM;
161 goto out_no_root;
162 }
Steve French50c2f752007-07-13 00:33:32 +0000163
Steve French7521a3c2007-07-11 18:30:34 +0000164#ifdef CONFIG_CIFS_EXPERIMENTAL
165 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
166 cFYI(1, ("export ops supported"));
167 sb->s_export_op = &cifs_export_ops;
168 }
169#endif /* EXPERIMENTAL */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
171 return 0;
172
173out_no_root:
174 cERROR(1, ("cifs_read_super: get root inode failed"));
175 if (inode)
176 iput(inode);
Steve French2c731af2008-08-11 22:28:53 +0000177
178 cifs_umount(sb, cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
180out_mount_failed:
Steve French4523cc32007-04-30 20:13:06 +0000181 if (cifs_sb) {
Igor Mammedove6ab1582008-01-11 01:49:48 +0000182#ifdef CONFIG_CIFS_DFS_UPCALL
183 if (cifs_sb->mountdata) {
184 kfree(cifs_sb->mountdata);
185 cifs_sb->mountdata = NULL;
186 }
187#endif
Steve French4523cc32007-04-30 20:13:06 +0000188 if (cifs_sb->local_nls)
Steve French50c2f752007-07-13 00:33:32 +0000189 unload_nls(cifs_sb->local_nls);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 kfree(cifs_sb);
191 }
192 return rc;
193}
194
195static void
196cifs_put_super(struct super_block *sb)
197{
198 int rc = 0;
199 struct cifs_sb_info *cifs_sb;
200
201 cFYI(1, ("In cifs_put_super"));
202 cifs_sb = CIFS_SB(sb);
Steve French4523cc32007-04-30 20:13:06 +0000203 if (cifs_sb == NULL) {
Steve French790fe572007-07-07 19:25:05 +0000204 cFYI(1, ("Empty cifs superblock info passed to unmount"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 return;
206 }
Steve French790fe572007-07-07 19:25:05 +0000207 rc = cifs_umount(sb, cifs_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +0000208 if (rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 cERROR(1, ("cifs_umount failed with return code %d", rc));
Igor Mammedove6ab1582008-01-11 01:49:48 +0000210#ifdef CONFIG_CIFS_DFS_UPCALL
211 if (cifs_sb->mountdata) {
212 kfree(cifs_sb->mountdata);
213 cifs_sb->mountdata = NULL;
214 }
215#endif
216
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 unload_nls(cifs_sb->local_nls);
218 kfree(cifs_sb);
219 return;
220}
221
222static int
David Howells726c3342006-06-23 02:02:58 -0700223cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224{
David Howells726c3342006-06-23 02:02:58 -0700225 struct super_block *sb = dentry->d_sb;
Steve French39da9842008-04-28 04:04:34 +0000226 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
227 struct cifsTconInfo *tcon = cifs_sb->tcon;
Steve Frenchc81156d2005-04-28 22:41:07 -0700228 int rc = -EOPNOTSUPP;
Steve French39da9842008-04-28 04:04:34 +0000229 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
231 xid = GetXid();
232
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 buf->f_type = CIFS_MAGIC_NUMBER;
234
Steve French39da9842008-04-28 04:04:34 +0000235 /*
236 * PATH_MAX may be too long - it would presumably be total path,
237 * but note that some servers (includinng Samba 3) have a shorter
238 * maximum path.
239 *
240 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
241 */
242 buf->f_namelen = PATH_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 buf->f_files = 0; /* undefined */
244 buf->f_ffree = 0; /* unlimited */
245
Steve French39da9842008-04-28 04:04:34 +0000246 /*
247 * We could add a second check for a QFS Unix capability bit
248 */
249 if ((tcon->ses->capabilities & CAP_UNIX) &&
250 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
251 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
Steve French39da9842008-04-28 04:04:34 +0000253 /*
254 * Only need to call the old QFSInfo if failed on newer one,
255 * e.g. by OS/2.
256 **/
257 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
258 rc = CIFSSMBQFSInfo(xid, tcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Steve French39da9842008-04-28 04:04:34 +0000260 /*
261 * Some old Windows servers also do not support level 103, retry with
262 * older level one if old server failed the previous call or we
263 * bypassed it because we detected that this was an older LANMAN sess
264 */
Steve French4523cc32007-04-30 20:13:06 +0000265 if (rc)
Steve French39da9842008-04-28 04:04:34 +0000266 rc = SMBOldQFSInfo(xid, tcon, buf);
267
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 FreeXid(xid);
Steve French39da9842008-04-28 04:04:34 +0000269 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270}
271
Al Viroe6305c42008-07-15 21:03:57 -0400272static int cifs_permission(struct inode *inode, int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273{
274 struct cifs_sb_info *cifs_sb;
275
276 cifs_sb = CIFS_SB(inode->i_sb);
277
Steve French26f57362007-08-30 22:09:15 +0000278 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 return 0;
Steve French26f57362007-08-30 22:09:15 +0000280 else /* file mode might have been restricted at mount time
Steve French50c2f752007-07-13 00:33:32 +0000281 on the client (above and beyond ACL on servers) for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 servers which do not support setting and viewing mode bits,
Steve French50c2f752007-07-13 00:33:32 +0000283 so allowing client to check permissions is useful */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 return generic_permission(inode, mask, NULL);
285}
286
Christoph Lametere18b8902006-12-06 20:33:20 -0800287static struct kmem_cache *cifs_inode_cachep;
288static struct kmem_cache *cifs_req_cachep;
289static struct kmem_cache *cifs_mid_cachep;
290struct kmem_cache *cifs_oplock_cachep;
291static struct kmem_cache *cifs_sm_req_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292mempool_t *cifs_sm_req_poolp;
293mempool_t *cifs_req_poolp;
294mempool_t *cifs_mid_poolp;
295
296static struct inode *
297cifs_alloc_inode(struct super_block *sb)
298{
299 struct cifsInodeInfo *cifs_inode;
Christoph Lametere94b1762006-12-06 20:33:17 -0800300 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 if (!cifs_inode)
302 return NULL;
303 cifs_inode->cifsAttrs = 0x20; /* default */
304 atomic_set(&cifs_inode->inUse, 0);
305 cifs_inode->time = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +0000306 cifs_inode->write_behind_rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 /* Until the file is open and we have gotten oplock
308 info back from the server, can not assume caching of
309 file data or metadata */
Steve French4b18f2a2008-04-29 00:06:05 +0000310 cifs_inode->clientCanCacheRead = false;
311 cifs_inode->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
Steve French50c2f752007-07-13 00:33:32 +0000313
Steve French1b2b2122007-02-17 04:30:54 +0000314 /* Can not set i_flags here - they get immediately overwritten
315 to zero by the VFS */
316/* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 INIT_LIST_HEAD(&cifs_inode->openFileList);
318 return &cifs_inode->vfs_inode;
319}
320
321static void
322cifs_destroy_inode(struct inode *inode)
323{
324 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
325}
326
327/*
328 * cifs_show_options() is for displaying mount options in /proc/mounts.
329 * Not all settable options are displayed but most of the important
330 * ones are.
331 */
332static int
333cifs_show_options(struct seq_file *s, struct vfsmount *m)
334{
335 struct cifs_sb_info *cifs_sb;
336
337 cifs_sb = CIFS_SB(m->mnt_sb);
338
339 if (cifs_sb) {
340 if (cifs_sb->tcon) {
Steve French004c46b2007-02-17 04:34:13 +0000341/* BB add prepath to mount options displayed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
343 if (cifs_sb->tcon->ses) {
344 if (cifs_sb->tcon->ses->userName)
345 seq_printf(s, ",username=%s",
346 cifs_sb->tcon->ses->userName);
Steve French4523cc32007-04-30 20:13:06 +0000347 if (cifs_sb->tcon->ses->domainName)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 seq_printf(s, ",domain=%s",
349 cifs_sb->tcon->ses->domainName);
350 }
Steve Frenchd5d18502007-10-17 21:31:52 +0000351 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) ||
352 !(cifs_sb->tcon->unix_ext))
353 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
354 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) ||
355 !(cifs_sb->tcon->unix_ext))
356 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
Steve French2b280fa2008-05-17 03:12:45 +0000357 if (!cifs_sb->tcon->unix_ext) {
358 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
359 cifs_sb->mnt_file_mode,
360 cifs_sb->mnt_dir_mode);
361 }
362 if (cifs_sb->tcon->seal)
363 seq_printf(s, ",seal");
Steve French89562b72008-05-19 22:26:42 +0000364 if (cifs_sb->tcon->nocase)
Steve French2b280fa2008-05-17 03:12:45 +0000365 seq_printf(s, ",nocase");
Steve French89562b72008-05-19 22:26:42 +0000366 if (cifs_sb->tcon->retry)
367 seq_printf(s, ",hard");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 }
Steve French4523cc32007-04-30 20:13:06 +0000369 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
370 seq_printf(s, ",posixpaths");
Steve French2b280fa2008-05-17 03:12:45 +0000371 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
372 seq_printf(s, ",setuids");
373 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
374 seq_printf(s, ",serverino");
375 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
376 seq_printf(s, ",directio");
377 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
378 seq_printf(s, ",nouser_xattr");
379 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
380 seq_printf(s, ",mapchars");
381 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
382 seq_printf(s, ",sfu");
383 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
384 seq_printf(s, ",nobrl");
385 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
386 seq_printf(s, ",cifsacl");
387 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
388 seq_printf(s, ",dynperm");
389 if (m->mnt_sb->s_flags & MS_POSIXACL)
390 seq_printf(s, ",acl");
391
Steve French50c2f752007-07-13 00:33:32 +0000392 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
393 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 }
395 return 0;
396}
397
398#ifdef CONFIG_CIFS_QUOTA
Steve French50c2f752007-07-13 00:33:32 +0000399int cifs_xquota_set(struct super_block *sb, int quota_type, qid_t qid,
400 struct fs_disk_quota *pdquota)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401{
402 int xid;
403 int rc = 0;
404 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
405 struct cifsTconInfo *pTcon;
Steve French50c2f752007-07-13 00:33:32 +0000406
Steve French4523cc32007-04-30 20:13:06 +0000407 if (cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 pTcon = cifs_sb->tcon;
409 else
410 return -EIO;
411
412
413 xid = GetXid();
Steve French4523cc32007-04-30 20:13:06 +0000414 if (pTcon) {
Steve French50c2f752007-07-13 00:33:32 +0000415 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 } else {
Cyrill Gorcunov95ba7362007-08-24 00:23:36 +0000417 rc = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 }
419
420 FreeXid(xid);
421 return rc;
422}
423
Steve French50c2f752007-07-13 00:33:32 +0000424int cifs_xquota_get(struct super_block *sb, int quota_type, qid_t qid,
425 struct fs_disk_quota *pdquota)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426{
427 int xid;
428 int rc = 0;
429 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
430 struct cifsTconInfo *pTcon;
431
Steve French4523cc32007-04-30 20:13:06 +0000432 if (cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 pTcon = cifs_sb->tcon;
434 else
435 return -EIO;
436
437 xid = GetXid();
Steve French4523cc32007-04-30 20:13:06 +0000438 if (pTcon) {
Steve French50c2f752007-07-13 00:33:32 +0000439 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 } else {
441 rc = -EIO;
442 }
443
444 FreeXid(xid);
445 return rc;
446}
447
Steve French50c2f752007-07-13 00:33:32 +0000448int cifs_xstate_set(struct super_block *sb, unsigned int flags, int operation)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449{
Steve French50c2f752007-07-13 00:33:32 +0000450 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 int rc = 0;
452 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
453 struct cifsTconInfo *pTcon;
454
Steve French4523cc32007-04-30 20:13:06 +0000455 if (cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 pTcon = cifs_sb->tcon;
457 else
458 return -EIO;
459
460 xid = GetXid();
Steve French4523cc32007-04-30 20:13:06 +0000461 if (pTcon) {
Steve French50c2f752007-07-13 00:33:32 +0000462 cFYI(1, ("flags: 0x%x operation: 0x%x", flags, operation));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 } else {
464 rc = -EIO;
465 }
466
467 FreeXid(xid);
468 return rc;
469}
470
Steve French50c2f752007-07-13 00:33:32 +0000471int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472{
473 int xid;
474 int rc = 0;
475 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
476 struct cifsTconInfo *pTcon;
477
Steve French4523cc32007-04-30 20:13:06 +0000478 if (cifs_sb) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 pTcon = cifs_sb->tcon;
480 } else {
481 return -EIO;
482 }
483 xid = GetXid();
Steve French4523cc32007-04-30 20:13:06 +0000484 if (pTcon) {
Steve French50c2f752007-07-13 00:33:32 +0000485 cFYI(1, ("pqstats %p", qstats));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 } else {
487 rc = -EIO;
488 }
489
490 FreeXid(xid);
491 return rc;
492}
493
494static struct quotactl_ops cifs_quotactl_ops = {
495 .set_xquota = cifs_xquota_set,
Roel Kluin6f7e8f32008-02-12 20:38:10 +0000496 .get_xquota = cifs_xquota_get,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 .set_xstate = cifs_xstate_set,
498 .get_xstate = cifs_xstate_get,
499};
500#endif
501
Al Viro42faad92008-04-24 07:21:56 -0400502static void cifs_umount_begin(struct super_block *sb)
Steve French68058e72005-10-10 10:34:22 -0700503{
Al Viro42faad92008-04-24 07:21:56 -0400504 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French50c2f752007-07-13 00:33:32 +0000505 struct cifsTconInfo *tcon;
Steve French68058e72005-10-10 10:34:22 -0700506
Steve French4523cc32007-04-30 20:13:06 +0000507 if (cifs_sb == NULL)
Steve French9e2e85f2005-10-10 14:28:38 -0700508 return;
509
510 tcon = cifs_sb->tcon;
Steve French4523cc32007-04-30 20:13:06 +0000511 if (tcon == NULL)
Steve French9e2e85f2005-10-10 14:28:38 -0700512 return;
Steve French5e1253b2005-10-10 14:06:37 -0700513 down(&tcon->tconSem);
514 if (atomic_read(&tcon->useCount) == 1)
515 tcon->tidStatus = CifsExiting;
516 up(&tcon->tconSem);
517
Steve French3a5ff612006-07-14 22:37:11 +0000518 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
Steve French7b7abfe2005-11-09 15:21:09 -0800519 /* cancel_notify_requests(tcon); */
Steve French50c2f752007-07-13 00:33:32 +0000520 if (tcon->ses && tcon->ses->server) {
521 cFYI(1, ("wake up tasks now - umount begin not complete"));
Steve French9e2e85f2005-10-10 14:28:38 -0700522 wake_up_all(&tcon->ses->server->request_q);
Steve French6ab16d22005-11-29 20:55:11 -0800523 wake_up_all(&tcon->ses->server->response_q);
524 msleep(1); /* yield */
525 /* we have to kick the requests once more */
526 wake_up_all(&tcon->ses->server->response_q);
527 msleep(1);
Steve French5e1253b2005-10-10 14:06:37 -0700528 }
529/* BB FIXME - finish add checks for tidStatus BB */
Steve French68058e72005-10-10 10:34:22 -0700530
531 return;
532}
Steve French68058e72005-10-10 10:34:22 -0700533
Steve Frenchbf97d282006-09-28 21:34:06 +0000534#ifdef CONFIG_CIFS_STATS2
535static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
536{
537 /* BB FIXME */
538 return 0;
539}
540#endif
541
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542static int cifs_remount(struct super_block *sb, int *flags, char *data)
543{
544 *flags |= MS_NODIRATIME;
545 return 0;
546}
547
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800548static const struct super_operations cifs_super_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 .put_super = cifs_put_super,
550 .statfs = cifs_statfs,
551 .alloc_inode = cifs_alloc_inode,
552 .destroy_inode = cifs_destroy_inode,
Steve French50c2f752007-07-13 00:33:32 +0000553/* .drop_inode = generic_delete_inode,
554 .delete_inode = cifs_delete_inode, */ /* Do not need above two
555 functions unless later we add lazy close of inodes or unless the
556 kernel forgets to call us with the same number of releases (closes)
557 as opens */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 .show_options = cifs_show_options,
Steve French7b7abfe2005-11-09 15:21:09 -0800559 .umount_begin = cifs_umount_begin,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 .remount_fs = cifs_remount,
Steve Frenchbf97d282006-09-28 21:34:06 +0000561#ifdef CONFIG_CIFS_STATS2
Steve Frenchf46d3e12006-09-30 01:08:55 +0000562 .show_stats = cifs_show_stats,
Steve Frenchbf97d282006-09-28 21:34:06 +0000563#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564};
565
David Howells454e2392006-06-23 02:02:57 -0700566static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567cifs_get_sb(struct file_system_type *fs_type,
David Howells454e2392006-06-23 02:02:57 -0700568 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569{
570 int rc;
571 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
572
573 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
574
575 if (IS_ERR(sb))
David Howells454e2392006-06-23 02:02:57 -0700576 return PTR_ERR(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577
578 sb->s_flags = flags;
579
Theodore Ts'o9b04c992006-03-24 03:15:10 -0800580 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 if (rc) {
582 up_write(&sb->s_umount);
583 deactivate_super(sb);
David Howells454e2392006-06-23 02:02:57 -0700584 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 }
586 sb->s_flags |= MS_ACTIVE;
David Howells454e2392006-06-23 02:02:57 -0700587 return simple_set_mnt(mnt, sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588}
589
Badari Pulavarty027445c2006-09-30 23:28:46 -0700590static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
591 unsigned long nr_segs, loff_t pos)
Steve French87c89dd2005-11-17 17:03:00 -0800592{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800593 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
Steve French87c89dd2005-11-17 17:03:00 -0800594 ssize_t written;
595
Badari Pulavarty027445c2006-09-30 23:28:46 -0700596 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
Steve French87c89dd2005-11-17 17:03:00 -0800597 if (!CIFS_I(inode)->clientCanCacheAll)
598 filemap_fdatawrite(inode->i_mapping);
599 return written;
600}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
Steve Frenchc32a0b62006-01-12 14:41:28 -0800602static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
603{
604 /* origin == SEEK_END => we must revalidate the cached file length */
Steve French0889a942006-09-23 22:11:07 +0000605 if (origin == SEEK_END) {
Steve French030e9d82007-02-01 04:27:59 +0000606 int retval;
607
608 /* some applications poll for the file length in this strange
609 way so we must seek to end on non-oplocked files by
610 setting the revalidate time to zero */
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000611 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
Steve French030e9d82007-02-01 04:27:59 +0000612
613 retval = cifs_revalidate(file->f_path.dentry);
Steve Frenchc32a0b62006-01-12 14:41:28 -0800614 if (retval < 0)
615 return (loff_t)retval;
616 }
Andi Kleen9465efc2008-06-27 11:05:24 +0200617 return generic_file_llseek_unlocked(file, offset, origin);
Steve Frenchc32a0b62006-01-12 14:41:28 -0800618}
619
Igor Mammedove6ab1582008-01-11 01:49:48 +0000620struct file_system_type cifs_fs_type = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 .owner = THIS_MODULE,
622 .name = "cifs",
623 .get_sb = cifs_get_sb,
624 .kill_sb = kill_anon_super,
625 /* .fs_flags */
626};
Arjan van de Ven754661f2007-02-12 00:55:38 -0800627const struct inode_operations cifs_dir_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 .create = cifs_create,
629 .lookup = cifs_lookup,
630 .getattr = cifs_getattr,
631 .unlink = cifs_unlink,
632 .link = cifs_hardlink,
633 .mkdir = cifs_mkdir,
634 .rmdir = cifs_rmdir,
635 .rename = cifs_rename,
636 .permission = cifs_permission,
637/* revalidate:cifs_revalidate, */
638 .setattr = cifs_setattr,
639 .symlink = cifs_symlink,
640 .mknod = cifs_mknod,
641#ifdef CONFIG_CIFS_XATTR
642 .setxattr = cifs_setxattr,
643 .getxattr = cifs_getxattr,
644 .listxattr = cifs_listxattr,
645 .removexattr = cifs_removexattr,
646#endif
647};
648
Arjan van de Ven754661f2007-02-12 00:55:38 -0800649const struct inode_operations cifs_file_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650/* revalidate:cifs_revalidate, */
651 .setattr = cifs_setattr,
652 .getattr = cifs_getattr, /* do we need this anymore? */
653 .rename = cifs_rename,
654 .permission = cifs_permission,
655#ifdef CONFIG_CIFS_XATTR
656 .setxattr = cifs_setxattr,
657 .getxattr = cifs_getxattr,
658 .listxattr = cifs_listxattr,
659 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000660#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661};
662
Arjan van de Ven754661f2007-02-12 00:55:38 -0800663const struct inode_operations cifs_symlink_inode_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000664 .readlink = generic_readlink,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 .follow_link = cifs_follow_link,
666 .put_link = cifs_put_link,
667 .permission = cifs_permission,
668 /* BB add the following two eventually */
669 /* revalidate: cifs_revalidate,
670 setattr: cifs_notify_change, *//* BB do we need notify change */
671#ifdef CONFIG_CIFS_XATTR
672 .setxattr = cifs_setxattr,
673 .getxattr = cifs_getxattr,
674 .listxattr = cifs_listxattr,
675 .removexattr = cifs_removexattr,
Steve French50c2f752007-07-13 00:33:32 +0000676#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677};
678
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800679const struct file_operations cifs_file_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800680 .read = do_sync_read,
681 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800682 .aio_read = generic_file_aio_read,
683 .aio_write = cifs_file_aio_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 .open = cifs_open,
685 .release = cifs_close,
686 .lock = cifs_lock,
687 .fsync = cifs_fsync,
688 .flush = cifs_flush,
689 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200690 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800691 .llseek = cifs_llseek,
Steve Frenchc67593a2005-04-28 22:41:04 -0700692#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000693 .unlocked_ioctl = cifs_ioctl,
Steve Frenchc67593a2005-04-28 22:41:04 -0700694#endif /* CONFIG_CIFS_POSIX */
695
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696#ifdef CONFIG_CIFS_EXPERIMENTAL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 .dir_notify = cifs_dir_notify,
698#endif /* CONFIG_CIFS_EXPERIMENTAL */
699};
700
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800701const struct file_operations cifs_file_direct_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000702 /* no mmap, no aio, no readv -
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 BB reevaluate whether they can be done with directio, no cache */
704 .read = cifs_user_read,
705 .write = cifs_user_write,
706 .open = cifs_open,
707 .release = cifs_close,
708 .lock = cifs_lock,
709 .fsync = cifs_fsync,
710 .flush = cifs_flush,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200711 .splice_read = generic_file_splice_read,
Steve Frenchc67593a2005-04-28 22:41:04 -0700712#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000713 .unlocked_ioctl = cifs_ioctl,
Steve Frenchc67593a2005-04-28 22:41:04 -0700714#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800715 .llseek = cifs_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716#ifdef CONFIG_CIFS_EXPERIMENTAL
717 .dir_notify = cifs_dir_notify,
718#endif /* CONFIG_CIFS_EXPERIMENTAL */
719};
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800720const struct file_operations cifs_file_nobrl_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800721 .read = do_sync_read,
722 .write = do_sync_write,
Steve French87c89dd2005-11-17 17:03:00 -0800723 .aio_read = generic_file_aio_read,
724 .aio_write = cifs_file_aio_write,
725 .open = cifs_open,
726 .release = cifs_close,
727 .fsync = cifs_fsync,
728 .flush = cifs_flush,
729 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200730 .splice_read = generic_file_splice_read,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800731 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800732#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000733 .unlocked_ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800734#endif /* CONFIG_CIFS_POSIX */
735
736#ifdef CONFIG_CIFS_EXPERIMENTAL
Steve French87c89dd2005-11-17 17:03:00 -0800737 .dir_notify = cifs_dir_notify,
Steve French8b94bcb2005-11-11 11:41:00 -0800738#endif /* CONFIG_CIFS_EXPERIMENTAL */
739};
740
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800741const struct file_operations cifs_file_direct_nobrl_ops = {
Steve French50c2f752007-07-13 00:33:32 +0000742 /* no mmap, no aio, no readv -
Steve French87c89dd2005-11-17 17:03:00 -0800743 BB reevaluate whether they can be done with directio, no cache */
744 .read = cifs_user_read,
745 .write = cifs_user_write,
746 .open = cifs_open,
747 .release = cifs_close,
748 .fsync = cifs_fsync,
749 .flush = cifs_flush,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +0200750 .splice_read = generic_file_splice_read,
Steve French8b94bcb2005-11-11 11:41:00 -0800751#ifdef CONFIG_CIFS_POSIX
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000752 .unlocked_ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800753#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800754 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800755#ifdef CONFIG_CIFS_EXPERIMENTAL
Steve French87c89dd2005-11-17 17:03:00 -0800756 .dir_notify = cifs_dir_notify,
Steve French8b94bcb2005-11-11 11:41:00 -0800757#endif /* CONFIG_CIFS_EXPERIMENTAL */
758};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800760const struct file_operations cifs_dir_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 .readdir = cifs_readdir,
762 .release = cifs_closedir,
763 .read = generic_read_dir,
764#ifdef CONFIG_CIFS_EXPERIMENTAL
765 .dir_notify = cifs_dir_notify,
766#endif /* CONFIG_CIFS_EXPERIMENTAL */
Steve Frenchf9ddcca2008-05-15 05:51:55 +0000767 .unlocked_ioctl = cifs_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768};
769
770static void
Alexey Dobriyan51cc5062008-07-25 19:45:34 -0700771cifs_init_once(void *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772{
773 struct cifsInodeInfo *cifsi = inode;
774
Christoph Lametera35afb82007-05-16 22:10:57 -0700775 inode_init_once(&cifsi->vfs_inode);
776 INIT_LIST_HEAD(&cifsi->lockList);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777}
778
779static int
780cifs_init_inodecache(void)
781{
782 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
Steve French26f57362007-08-30 22:09:15 +0000783 sizeof(struct cifsInodeInfo),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800784 0, (SLAB_RECLAIM_ACCOUNT|
785 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +0900786 cifs_init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 if (cifs_inode_cachep == NULL)
788 return -ENOMEM;
789
790 return 0;
791}
792
793static void
794cifs_destroy_inodecache(void)
795{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700796 kmem_cache_destroy(cifs_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797}
798
799static int
800cifs_init_request_bufs(void)
801{
Steve French4523cc32007-04-30 20:13:06 +0000802 if (CIFSMaxBufSize < 8192) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
804 Unicode path name has to fit in any SMB/CIFS path based frames */
805 CIFSMaxBufSize = 8192;
806 } else if (CIFSMaxBufSize > 1024*127) {
807 CIFSMaxBufSize = 1024 * 127;
808 } else {
809 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
810 }
811/* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
812 cifs_req_cachep = kmem_cache_create("cifs_request",
813 CIFSMaxBufSize +
814 MAX_CIFS_HDR_SIZE, 0,
Paul Mundt20c2df82007-07-20 10:11:58 +0900815 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 if (cifs_req_cachep == NULL)
817 return -ENOMEM;
818
Steve French4523cc32007-04-30 20:13:06 +0000819 if (cifs_min_rcv < 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 cifs_min_rcv = 1;
821 else if (cifs_min_rcv > 64) {
822 cifs_min_rcv = 64;
Steve French50c2f752007-07-13 00:33:32 +0000823 cERROR(1, ("cifs_min_rcv set to maximum (64)"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 }
825
Matthew Dobson93d23412006-03-26 01:37:50 -0800826 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
827 cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828
Steve French4523cc32007-04-30 20:13:06 +0000829 if (cifs_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 kmem_cache_destroy(cifs_req_cachep);
831 return -ENOMEM;
832 }
Steve Frenchec637e32005-12-12 20:53:18 -0800833 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 almost all handle based requests (but not write response, nor is it
835 sufficient for path based requests). A smaller size would have
Steve French50c2f752007-07-13 00:33:32 +0000836 been more efficient (compacting multiple slab items on one 4k page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 for the case in which debug was on, but this larger size allows
838 more SMBs to use small buffer alloc and is still much more
Steve French6dc0f872007-07-06 23:13:06 +0000839 efficient to alloc 1 per page off the slab compared to 17K (5page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 alloc of large cifs buffers even when page debugging is on */
841 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
Steve French6dc0f872007-07-06 23:13:06 +0000842 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +0900843 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 if (cifs_sm_req_cachep == NULL) {
845 mempool_destroy(cifs_req_poolp);
846 kmem_cache_destroy(cifs_req_cachep);
Steve French6dc0f872007-07-06 23:13:06 +0000847 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 }
849
Steve French4523cc32007-04-30 20:13:06 +0000850 if (cifs_min_small < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 cifs_min_small = 2;
852 else if (cifs_min_small > 256) {
853 cifs_min_small = 256;
Steve French6dc0f872007-07-06 23:13:06 +0000854 cFYI(1, ("cifs_min_small set to maximum (256)"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 }
856
Matthew Dobson93d23412006-03-26 01:37:50 -0800857 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
858 cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859
Steve French4523cc32007-04-30 20:13:06 +0000860 if (cifs_sm_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 mempool_destroy(cifs_req_poolp);
862 kmem_cache_destroy(cifs_req_cachep);
863 kmem_cache_destroy(cifs_sm_req_cachep);
864 return -ENOMEM;
865 }
866
867 return 0;
868}
869
870static void
871cifs_destroy_request_bufs(void)
872{
873 mempool_destroy(cifs_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700874 kmem_cache_destroy(cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 mempool_destroy(cifs_sm_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700876 kmem_cache_destroy(cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877}
878
879static int
880cifs_init_mids(void)
881{
882 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
Steve French26f57362007-08-30 22:09:15 +0000883 sizeof(struct mid_q_entry), 0,
884 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 if (cifs_mid_cachep == NULL)
886 return -ENOMEM;
887
Matthew Dobson93d23412006-03-26 01:37:50 -0800888 /* 3 is a reasonable minimum number of simultaneous operations */
889 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
Steve French4523cc32007-04-30 20:13:06 +0000890 if (cifs_mid_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 kmem_cache_destroy(cifs_mid_cachep);
892 return -ENOMEM;
893 }
894
895 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
Steve French26f57362007-08-30 22:09:15 +0000896 sizeof(struct oplock_q_entry), 0,
897 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 if (cifs_oplock_cachep == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 mempool_destroy(cifs_mid_poolp);
Akinobu Mitae6985c72007-06-04 16:14:59 +0000900 kmem_cache_destroy(cifs_mid_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 return -ENOMEM;
902 }
903
904 return 0;
905}
906
907static void
908cifs_destroy_mids(void)
909{
910 mempool_destroy(cifs_mid_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700911 kmem_cache_destroy(cifs_mid_cachep);
912 kmem_cache_destroy(cifs_oplock_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913}
914
Steve French50c2f752007-07-13 00:33:32 +0000915static int cifs_oplock_thread(void *dummyarg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916{
Steve French6dc0f872007-07-06 23:13:06 +0000917 struct oplock_q_entry *oplock_item;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 struct cifsTconInfo *pTcon;
Steve French6dc0f872007-07-06 23:13:06 +0000919 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 __u16 netfid;
Jeff Laytoncea21802007-11-20 23:19:03 +0000921 int rc, waitrc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700923 set_freezable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 do {
Steve French6dc0f872007-07-06 23:13:06 +0000925 if (try_to_freeze())
Steve Frenchede13272005-08-30 20:10:14 -0700926 continue;
Steve French50c2f752007-07-13 00:33:32 +0000927
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 spin_lock(&GlobalMid_Lock);
Steve French4523cc32007-04-30 20:13:06 +0000929 if (list_empty(&GlobalOplock_Q)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 spin_unlock(&GlobalMid_Lock);
931 set_current_state(TASK_INTERRUPTIBLE);
932 schedule_timeout(39*HZ);
933 } else {
Steve French6dc0f872007-07-06 23:13:06 +0000934 oplock_item = list_entry(GlobalOplock_Q.next,
Steve Frenchad8b15f2008-08-08 21:10:16 +0000935 struct oplock_q_entry, qhead);
936 cFYI(1, ("found oplock item to write out"));
937 pTcon = oplock_item->tcon;
938 inode = oplock_item->pinode;
939 netfid = oplock_item->netfid;
940 spin_unlock(&GlobalMid_Lock);
941 DeleteOplockQEntry(oplock_item);
942 /* can not grab inode sem here since it would
Steve French6dc0f872007-07-06 23:13:06 +0000943 deadlock when oplock received on delete
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800944 since vfs_unlink holds the i_mutex across
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 the call */
Steve Frenchad8b15f2008-08-08 21:10:16 +0000946 /* mutex_lock(&inode->i_mutex);*/
947 if (S_ISREG(inode->i_mode)) {
948 rc = filemap_fdatawrite(inode->i_mapping);
949 if (CIFS_I(inode)->clientCanCacheRead == 0) {
950 waitrc = filemap_fdatawait(
951 inode->i_mapping);
952 invalidate_remote_inode(inode);
953 }
954 if (rc == 0)
955 rc = waitrc;
956 } else
957 rc = 0;
958 /* mutex_unlock(&inode->i_mutex);*/
959 if (rc)
960 CIFS_I(inode)->write_behind_rc = rc;
961 cFYI(1, ("Oplock flush inode %p rc %d",
962 inode, rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
Steve French6dc0f872007-07-06 23:13:06 +0000964 /* releasing stale oplock after recent reconnect
965 of smb session using a now incorrect file
966 handle is not a data integrity issue but do
967 not bother sending an oplock release if session
968 to server still is disconnected since oplock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 already released by the server in that case */
Steve Frenchad8b15f2008-08-08 21:10:16 +0000970 if (pTcon->tidStatus != CifsNeedReconnect) {
971 rc = CIFSSMBLock(0, pTcon, netfid,
972 0 /* len */ , 0 /* offset */, 0,
973 0, LOCKING_ANDX_OPLOCK_RELEASE,
974 false /* wait flag */);
975 cFYI(1, ("Oplock release rc = %d", rc));
976 }
Steve French68058e72005-10-10 10:34:22 -0700977 set_current_state(TASK_INTERRUPTIBLE);
978 schedule_timeout(1); /* yield in case q were corrupt */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 }
Steve French45af7a02006-04-21 22:52:25 +0000980 } while (!kthread_should_stop());
981
982 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983}
984
Steve French50c2f752007-07-13 00:33:32 +0000985static int cifs_dnotify_thread(void *dummyarg)
Steve French8d0d5092005-08-18 09:41:43 -0700986{
Steve French6ab16d22005-11-29 20:55:11 -0800987 struct list_head *tmp;
988 struct cifsSesInfo *ses;
989
Steve French8d0d5092005-08-18 09:41:43 -0700990 do {
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000991 if (try_to_freeze())
Steve French16abbec2005-08-30 13:10:14 -0700992 continue;
Steve French8d0d5092005-08-18 09:41:43 -0700993 set_current_state(TASK_INTERRUPTIBLE);
Steve French6ab16d22005-11-29 20:55:11 -0800994 schedule_timeout(15*HZ);
995 read_lock(&GlobalSMBSeslock);
996 /* check if any stuck requests that need
997 to be woken up and wakeq so the
998 thread can wake up and error out */
999 list_for_each(tmp, &GlobalSMBSessionList) {
Steve French6dc0f872007-07-06 23:13:06 +00001000 ses = list_entry(tmp, struct cifsSesInfo,
Steve French6ab16d22005-11-29 20:55:11 -08001001 cifsSessionList);
Steve Frenchad8b15f2008-08-08 21:10:16 +00001002 if (ses->server && atomic_read(&ses->server->inFlight))
Steve French6ab16d22005-11-29 20:55:11 -08001003 wake_up_all(&ses->server->response_q);
1004 }
1005 read_unlock(&GlobalSMBSeslock);
Steve French45af7a02006-04-21 22:52:25 +00001006 } while (!kthread_should_stop());
1007
1008 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009}
1010
1011static int __init
1012init_cifs(void)
1013{
1014 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 cifs_proc_init();
Steve French2cd646a2006-09-28 19:43:08 +00001016/* INIT_LIST_HEAD(&GlobalServerList);*/ /* BB not implemented yet */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 INIT_LIST_HEAD(&GlobalSMBSessionList);
1018 INIT_LIST_HEAD(&GlobalTreeConnectionList);
1019 INIT_LIST_HEAD(&GlobalOplock_Q);
Steve French4ca9c192005-10-10 19:52:13 -07001020#ifdef CONFIG_CIFS_EXPERIMENTAL
1021 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1022 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
Steve French6dc0f872007-07-06 23:13:06 +00001023#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024/*
1025 * Initialize Global counters
1026 */
1027 atomic_set(&sesInfoAllocCount, 0);
1028 atomic_set(&tconInfoAllocCount, 0);
Steve French6dc0f872007-07-06 23:13:06 +00001029 atomic_set(&tcpSesAllocCount, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 atomic_set(&tcpSesReconnectCount, 0);
1031 atomic_set(&tconInfoReconnectCount, 0);
1032
1033 atomic_set(&bufAllocCount, 0);
Steve French4498eed52005-12-03 13:58:57 -08001034 atomic_set(&smBufAllocCount, 0);
1035#ifdef CONFIG_CIFS_STATS2
1036 atomic_set(&totBufAllocCount, 0);
1037 atomic_set(&totSmBufAllocCount, 0);
1038#endif /* CONFIG_CIFS_STATS2 */
1039
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 atomic_set(&midCount, 0);
1041 GlobalCurrentXid = 0;
1042 GlobalTotalActiveXid = 0;
1043 GlobalMaxActiveXid = 0;
Steve French2cd646a2006-09-28 19:43:08 +00001044 memset(Local_System_Name, 0, 15);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 rwlock_init(&GlobalSMBSeslock);
1046 spin_lock_init(&GlobalMid_Lock);
1047
Steve French4523cc32007-04-30 20:13:06 +00001048 if (cifs_max_pending < 2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 cifs_max_pending = 2;
Steve French6dc0f872007-07-06 23:13:06 +00001050 cFYI(1, ("cifs_max_pending set to min of 2"));
Steve French4523cc32007-04-30 20:13:06 +00001051 } else if (cifs_max_pending > 256) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 cifs_max_pending = 256;
Steve French6dc0f872007-07-06 23:13:06 +00001053 cFYI(1, ("cifs_max_pending set to max of 256"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 }
1055
1056 rc = cifs_init_inodecache();
Steve French45af7a02006-04-21 22:52:25 +00001057 if (rc)
1058 goto out_clean_proc;
1059
1060 rc = cifs_init_mids();
1061 if (rc)
1062 goto out_destroy_inodecache;
1063
1064 rc = cifs_init_request_bufs();
1065 if (rc)
1066 goto out_destroy_mids;
1067
1068 rc = register_filesystem(&cifs_fs_type);
1069 if (rc)
1070 goto out_destroy_request_bufs;
Jeff Layton84a15b92007-11-03 05:02:24 +00001071#ifdef CONFIG_CIFS_UPCALL
1072 rc = register_key_type(&cifs_spnego_key_type);
1073 if (rc)
1074 goto out_unregister_filesystem;
1075#endif
Steve French61033352008-01-09 16:21:36 +00001076#ifdef CONFIG_CIFS_DFS_UPCALL
1077 rc = register_key_type(&key_type_dns_resolver);
1078 if (rc)
1079 goto out_unregister_key_type;
1080#endif
Steve French45af7a02006-04-21 22:52:25 +00001081 oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
1082 if (IS_ERR(oplockThread)) {
1083 rc = PTR_ERR(oplockThread);
Steve French6dc0f872007-07-06 23:13:06 +00001084 cERROR(1, ("error %d create oplock thread", rc));
Steve French61033352008-01-09 16:21:36 +00001085 goto out_unregister_dfs_key_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 }
Steve French45af7a02006-04-21 22:52:25 +00001087
1088 dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
1089 if (IS_ERR(dnotifyThread)) {
1090 rc = PTR_ERR(dnotifyThread);
Steve French6dc0f872007-07-06 23:13:06 +00001091 cERROR(1, ("error %d create dnotify thread", rc));
Steve French45af7a02006-04-21 22:52:25 +00001092 goto out_stop_oplock_thread;
1093 }
1094
1095 return 0;
1096
1097 out_stop_oplock_thread:
1098 kthread_stop(oplockThread);
Steve French61033352008-01-09 16:21:36 +00001099 out_unregister_dfs_key_type:
1100#ifdef CONFIG_CIFS_DFS_UPCALL
1101 unregister_key_type(&key_type_dns_resolver);
Jeff Layton84a15b92007-11-03 05:02:24 +00001102 out_unregister_key_type:
Steve French61033352008-01-09 16:21:36 +00001103#endif
Jeff Layton84a15b92007-11-03 05:02:24 +00001104#ifdef CONFIG_CIFS_UPCALL
1105 unregister_key_type(&cifs_spnego_key_type);
Steve French45af7a02006-04-21 22:52:25 +00001106 out_unregister_filesystem:
Jeff Layton84a15b92007-11-03 05:02:24 +00001107#endif
Steve French45af7a02006-04-21 22:52:25 +00001108 unregister_filesystem(&cifs_fs_type);
1109 out_destroy_request_bufs:
1110 cifs_destroy_request_bufs();
1111 out_destroy_mids:
1112 cifs_destroy_mids();
1113 out_destroy_inodecache:
1114 cifs_destroy_inodecache();
1115 out_clean_proc:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 cifs_proc_clean();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 return rc;
1118}
1119
1120static void __exit
1121exit_cifs(void)
1122{
Steve French90c81e02008-02-12 20:32:36 +00001123 cFYI(DBG2, ("exit_cifs"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 cifs_proc_clean();
Steve French61033352008-01-09 16:21:36 +00001125#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov78d31a32008-04-24 12:56:07 +04001126 cifs_dfs_release_automount_timer();
Steve French61033352008-01-09 16:21:36 +00001127 unregister_key_type(&key_type_dns_resolver);
1128#endif
Jeff Layton84a15b92007-11-03 05:02:24 +00001129#ifdef CONFIG_CIFS_UPCALL
1130 unregister_key_type(&cifs_spnego_key_type);
1131#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 unregister_filesystem(&cifs_fs_type);
1133 cifs_destroy_inodecache();
1134 cifs_destroy_mids();
1135 cifs_destroy_request_bufs();
Steve French45af7a02006-04-21 22:52:25 +00001136 kthread_stop(oplockThread);
1137 kthread_stop(dnotifyThread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138}
1139
1140MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
Steve French6dc0f872007-07-06 23:13:06 +00001141MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142MODULE_DESCRIPTION
Steve French63135e02007-07-17 17:34:02 +00001143 ("VFS to access servers complying with the SNIA CIFS Specification "
1144 "e.g. Samba and Windows");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145MODULE_VERSION(CIFS_VERSION);
1146module_init(init_cifs)
1147module_exit(exit_cifs)