blob: c262d8874ce97b87cc6b8c137c44d230621d3d00 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/cifsfs.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2004
5 * 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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include "cifsfs.h"
38#include "cifspdu.h"
39#define DECLARE_GLOBALS_HERE
40#include "cifsglob.h"
41#include "cifsproto.h"
42#include "cifs_debug.h"
43#include "cifs_fs_sb.h"
44#include <linux/mm.h>
45#define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
46
47#ifdef CONFIG_CIFS_QUOTA
48static struct quotactl_ops cifs_quotactl_ops;
49#endif
50
51int cifsFYI = 0;
52int cifsERROR = 1;
53int traceSMB = 0;
54unsigned int oplockEnabled = 1;
55unsigned int experimEnabled = 0;
56unsigned int linuxExtEnabled = 1;
57unsigned int lookupCacheEnabled = 1;
58unsigned int multiuser_mount = 0;
59unsigned int extended_security = 0;
60unsigned int ntlmv2_support = 0;
61unsigned int sign_CIFS_PDUs = 1;
62extern struct task_struct * oplockThread; /* remove sparse warning */
63struct task_struct * oplockThread = NULL;
Steve French8d0d5092005-08-18 09:41:43 -070064extern struct task_struct * dnotifyThread; /* remove sparse warning */
65struct task_struct * dnotifyThread = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070066unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
67module_param(CIFSMaxBufSize, int, 0);
68MODULE_PARM_DESC(CIFSMaxBufSize,"Network buffer size (not including header). Default: 16384 Range: 8192 to 130048");
69unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
70module_param(cifs_min_rcv, int, 0);
71MODULE_PARM_DESC(cifs_min_rcv,"Network buffers in pool. Default: 4 Range: 1 to 64");
72unsigned int cifs_min_small = 30;
73module_param(cifs_min_small, int, 0);
74MODULE_PARM_DESC(cifs_min_small,"Small network buffers in pool. Default: 30 Range: 2 to 256");
75unsigned int cifs_max_pending = CIFS_MAX_REQ;
76module_param(cifs_max_pending, int, 0);
77MODULE_PARM_DESC(cifs_max_pending,"Simultaneous requests to server. Default: 50 Range: 2 to 256");
78
Linus Torvalds1da177e2005-04-16 15:20:36 -070079extern mempool_t *cifs_sm_req_poolp;
80extern mempool_t *cifs_req_poolp;
81extern mempool_t *cifs_mid_poolp;
82
83extern kmem_cache_t *cifs_oplock_cachep;
84
85static int
86cifs_read_super(struct super_block *sb, void *data,
87 const char *devname, int silent)
88{
89 struct inode *inode;
90 struct cifs_sb_info *cifs_sb;
91 int rc = 0;
92
93 sb->s_flags |= MS_NODIRATIME; /* and probably even noatime */
Eric Sesterhenna048d7a2006-02-21 22:33:09 +000094 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info),GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 cifs_sb = CIFS_SB(sb);
96 if(cifs_sb == NULL)
97 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
99 rc = cifs_mount(sb, cifs_sb, data, devname);
100
101 if (rc) {
102 if (!silent)
103 cERROR(1,
104 ("cifs_mount failed w/return code = %d", rc));
105 goto out_mount_failed;
106 }
107
108 sb->s_magic = CIFS_MAGIC_NUMBER;
109 sb->s_op = &cifs_super_ops;
110/* if(cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
111 sb->s_blocksize = cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
112#ifdef CONFIG_CIFS_QUOTA
113 sb->s_qcop = &cifs_quotactl_ops;
114#endif
115 sb->s_blocksize = CIFS_MAX_MSGSIZE;
116 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
117 inode = iget(sb, ROOT_I);
118
119 if (!inode) {
120 rc = -ENOMEM;
121 goto out_no_root;
122 }
123
124 sb->s_root = d_alloc_root(inode);
125
126 if (!sb->s_root) {
127 rc = -ENOMEM;
128 goto out_no_root;
129 }
130
131 return 0;
132
133out_no_root:
134 cERROR(1, ("cifs_read_super: get root inode failed"));
135 if (inode)
136 iput(inode);
137
138out_mount_failed:
139 if(cifs_sb) {
140 if(cifs_sb->local_nls)
141 unload_nls(cifs_sb->local_nls);
142 kfree(cifs_sb);
143 }
144 return rc;
145}
146
147static void
148cifs_put_super(struct super_block *sb)
149{
150 int rc = 0;
151 struct cifs_sb_info *cifs_sb;
152
153 cFYI(1, ("In cifs_put_super"));
154 cifs_sb = CIFS_SB(sb);
155 if(cifs_sb == NULL) {
156 cFYI(1,("Empty cifs superblock info passed to unmount"));
157 return;
158 }
159 rc = cifs_umount(sb, cifs_sb);
160 if (rc) {
161 cERROR(1, ("cifs_umount failed with return code %d", rc));
162 }
163 unload_nls(cifs_sb->local_nls);
164 kfree(cifs_sb);
165 return;
166}
167
168static int
169cifs_statfs(struct super_block *sb, struct kstatfs *buf)
170{
Steve Frenchc81156d2005-04-28 22:41:07 -0700171 int xid;
172 int rc = -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 struct cifs_sb_info *cifs_sb;
174 struct cifsTconInfo *pTcon;
175
176 xid = GetXid();
177
178 cifs_sb = CIFS_SB(sb);
179 pTcon = cifs_sb->tcon;
180
181 buf->f_type = CIFS_MAGIC_NUMBER;
182
183 /* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */
Steve Frenchc81156d2005-04-28 22:41:07 -0700184 buf->f_namelen = PATH_MAX; /* PATH_MAX may be too long - it would
185 presumably be total path, but note
186 that some servers (includinng Samba 3)
187 have a shorter maximum path */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 buf->f_files = 0; /* undefined */
189 buf->f_ffree = 0; /* unlimited */
190
191#ifdef CONFIG_CIFS_EXPERIMENTAL
192/* BB we could add a second check for a QFS Unix capability bit */
Steve Frenchf28ac912005-04-28 22:41:07 -0700193/* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */
Steve Frenchc81156d2005-04-28 22:41:07 -0700194 if ((pTcon->ses->capabilities & CAP_UNIX) && (CIFS_POSIX_EXTENSIONS &
195 le64_to_cpu(pTcon->fsUnixInfo.Capability)))
Steve French737b7582005-04-28 22:41:06 -0700196 rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
198 /* Only need to call the old QFSInfo if failed
199 on newer one */
200 if(rc)
201#endif /* CIFS_EXPERIMENTAL */
Steve French737b7582005-04-28 22:41:06 -0700202 rc = CIFSSMBQFSInfo(xid, pTcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
Steve French20962432005-09-21 22:05:57 -0700204 /* Old Windows servers do not support level 103, retry with level
205 one if old server failed the previous call */
206 if(rc)
207 rc = SMBOldQFSInfo(xid, pTcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 /*
209 int f_type;
210 __fsid_t f_fsid;
211 int f_namelen; */
Steve Frenchc81156d2005-04-28 22:41:07 -0700212 /* BB get from info in tcon struct at mount time call to QFSAttrInfo */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 FreeXid(xid);
Steve Frenchc81156d2005-04-28 22:41:07 -0700214 return 0; /* always return success? what if volume is no
215 longer available? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216}
217
218static int cifs_permission(struct inode * inode, int mask, struct nameidata *nd)
219{
220 struct cifs_sb_info *cifs_sb;
221
222 cifs_sb = CIFS_SB(inode->i_sb);
223
224 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
225 return 0;
226 } else /* file mode might have been restricted at mount time
227 on the client (above and beyond ACL on servers) for
228 servers which do not support setting and viewing mode bits,
229 so allowing client to check permissions is useful */
230 return generic_permission(inode, mask, NULL);
231}
232
233static kmem_cache_t *cifs_inode_cachep;
234static kmem_cache_t *cifs_req_cachep;
235static kmem_cache_t *cifs_mid_cachep;
236kmem_cache_t *cifs_oplock_cachep;
237static kmem_cache_t *cifs_sm_req_cachep;
238mempool_t *cifs_sm_req_poolp;
239mempool_t *cifs_req_poolp;
240mempool_t *cifs_mid_poolp;
241
242static struct inode *
243cifs_alloc_inode(struct super_block *sb)
244{
245 struct cifsInodeInfo *cifs_inode;
246 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, SLAB_KERNEL);
247 if (!cifs_inode)
248 return NULL;
249 cifs_inode->cifsAttrs = 0x20; /* default */
250 atomic_set(&cifs_inode->inUse, 0);
251 cifs_inode->time = 0;
252 /* Until the file is open and we have gotten oplock
253 info back from the server, can not assume caching of
254 file data or metadata */
255 cifs_inode->clientCanCacheRead = FALSE;
256 cifs_inode->clientCanCacheAll = FALSE;
257 cifs_inode->vfs_inode.i_blksize = CIFS_MAX_MSGSIZE;
258 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
Steve Frenche30dcf32005-09-20 20:49:16 -0700259 cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 INIT_LIST_HEAD(&cifs_inode->openFileList);
261 return &cifs_inode->vfs_inode;
262}
263
264static void
265cifs_destroy_inode(struct inode *inode)
266{
267 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
268}
269
270/*
271 * cifs_show_options() is for displaying mount options in /proc/mounts.
272 * Not all settable options are displayed but most of the important
273 * ones are.
274 */
275static int
276cifs_show_options(struct seq_file *s, struct vfsmount *m)
277{
278 struct cifs_sb_info *cifs_sb;
279
280 cifs_sb = CIFS_SB(m->mnt_sb);
281
282 if (cifs_sb) {
283 if (cifs_sb->tcon) {
284 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
285 if (cifs_sb->tcon->ses) {
286 if (cifs_sb->tcon->ses->userName)
287 seq_printf(s, ",username=%s",
288 cifs_sb->tcon->ses->userName);
289 if(cifs_sb->tcon->ses->domainName)
290 seq_printf(s, ",domain=%s",
291 cifs_sb->tcon->ses->domainName);
292 }
293 }
294 seq_printf(s, ",rsize=%d",cifs_sb->rsize);
295 seq_printf(s, ",wsize=%d",cifs_sb->wsize);
296 }
297 return 0;
298}
299
300#ifdef CONFIG_CIFS_QUOTA
301int cifs_xquota_set(struct super_block * sb, int quota_type, qid_t qid,
302 struct fs_disk_quota * pdquota)
303{
304 int xid;
305 int rc = 0;
306 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
307 struct cifsTconInfo *pTcon;
308
309 if(cifs_sb)
310 pTcon = cifs_sb->tcon;
311 else
312 return -EIO;
313
314
315 xid = GetXid();
316 if(pTcon) {
317 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
318 } else {
319 return -EIO;
320 }
321
322 FreeXid(xid);
323 return rc;
324}
325
326int cifs_xquota_get(struct super_block * sb, int quota_type, qid_t qid,
327 struct fs_disk_quota * pdquota)
328{
329 int xid;
330 int rc = 0;
331 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
332 struct cifsTconInfo *pTcon;
333
334 if(cifs_sb)
335 pTcon = cifs_sb->tcon;
336 else
337 return -EIO;
338
339 xid = GetXid();
340 if(pTcon) {
341 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
342 } else {
343 rc = -EIO;
344 }
345
346 FreeXid(xid);
347 return rc;
348}
349
350int cifs_xstate_set(struct super_block * sb, unsigned int flags, int operation)
351{
352 int xid;
353 int rc = 0;
354 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
355 struct cifsTconInfo *pTcon;
356
357 if(cifs_sb)
358 pTcon = cifs_sb->tcon;
359 else
360 return -EIO;
361
362 xid = GetXid();
363 if(pTcon) {
364 cFYI(1,("flags: 0x%x operation: 0x%x",flags,operation));
365 } else {
366 rc = -EIO;
367 }
368
369 FreeXid(xid);
370 return rc;
371}
372
373int cifs_xstate_get(struct super_block * sb, struct fs_quota_stat *qstats)
374{
375 int xid;
376 int rc = 0;
377 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
378 struct cifsTconInfo *pTcon;
379
380 if(cifs_sb) {
381 pTcon = cifs_sb->tcon;
382 } else {
383 return -EIO;
384 }
385 xid = GetXid();
386 if(pTcon) {
387 cFYI(1,("pqstats %p",qstats));
388 } else {
389 rc = -EIO;
390 }
391
392 FreeXid(xid);
393 return rc;
394}
395
396static struct quotactl_ops cifs_quotactl_ops = {
397 .set_xquota = cifs_xquota_set,
398 .get_xquota = cifs_xquota_set,
399 .set_xstate = cifs_xstate_set,
400 .get_xstate = cifs_xstate_get,
401};
402#endif
403
Steve French7b7abfe2005-11-09 15:21:09 -0800404#ifdef CONFIG_CIFS_EXPERIMENTAL
Steve French68058e72005-10-10 10:34:22 -0700405static void cifs_umount_begin(struct super_block * sblock)
406{
Steve French5e1253b2005-10-10 14:06:37 -0700407 struct cifs_sb_info *cifs_sb;
Steve French9e2e85f2005-10-10 14:28:38 -0700408 struct cifsTconInfo * tcon;
Steve French68058e72005-10-10 10:34:22 -0700409
Steve French34210f32005-10-10 14:31:13 -0700410 cifs_sb = CIFS_SB(sblock);
Steve French5e1253b2005-10-10 14:06:37 -0700411 if(cifs_sb == NULL)
Steve French9e2e85f2005-10-10 14:28:38 -0700412 return;
413
414 tcon = cifs_sb->tcon;
415 if(tcon == NULL)
416 return;
Steve French5e1253b2005-10-10 14:06:37 -0700417 down(&tcon->tconSem);
418 if (atomic_read(&tcon->useCount) == 1)
419 tcon->tidStatus = CifsExiting;
420 up(&tcon->tconSem);
421
Steve French7b7abfe2005-11-09 15:21:09 -0800422 /* cancel_brl_requests(tcon); */
423 /* cancel_notify_requests(tcon); */
Steve French9e2e85f2005-10-10 14:28:38 -0700424 if(tcon->ses && tcon->ses->server)
Steve French5e1253b2005-10-10 14:06:37 -0700425 {
Steve French7b7abfe2005-11-09 15:21:09 -0800426 cFYI(1,("wake up tasks now - umount begin not complete"));
Steve French9e2e85f2005-10-10 14:28:38 -0700427 wake_up_all(&tcon->ses->server->request_q);
Steve French6ab16d22005-11-29 20:55:11 -0800428 wake_up_all(&tcon->ses->server->response_q);
429 msleep(1); /* yield */
430 /* we have to kick the requests once more */
431 wake_up_all(&tcon->ses->server->response_q);
432 msleep(1);
Steve French5e1253b2005-10-10 14:06:37 -0700433 }
434/* BB FIXME - finish add checks for tidStatus BB */
Steve French68058e72005-10-10 10:34:22 -0700435
436 return;
437}
Steve French7b7abfe2005-11-09 15:21:09 -0800438#endif
Steve French68058e72005-10-10 10:34:22 -0700439
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440static int cifs_remount(struct super_block *sb, int *flags, char *data)
441{
442 *flags |= MS_NODIRATIME;
443 return 0;
444}
445
446struct super_operations cifs_super_ops = {
447 .read_inode = cifs_read_inode,
448 .put_super = cifs_put_super,
449 .statfs = cifs_statfs,
450 .alloc_inode = cifs_alloc_inode,
451 .destroy_inode = cifs_destroy_inode,
452/* .drop_inode = generic_delete_inode,
453 .delete_inode = cifs_delete_inode, *//* Do not need the above two functions
454 unless later we add lazy close of inodes or unless the kernel forgets to call
455 us with the same number of releases (closes) as opens */
456 .show_options = cifs_show_options,
Steve French7b7abfe2005-11-09 15:21:09 -0800457#ifdef CONFIG_CIFS_EXPERIMENTAL
458 .umount_begin = cifs_umount_begin,
459#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 .remount_fs = cifs_remount,
461};
462
463static struct super_block *
464cifs_get_sb(struct file_system_type *fs_type,
465 int flags, const char *dev_name, void *data)
466{
467 int rc;
468 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
469
470 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
471
472 if (IS_ERR(sb))
473 return sb;
474
475 sb->s_flags = flags;
476
Theodore Ts'o9b04c992006-03-24 03:15:10 -0800477 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 if (rc) {
479 up_write(&sb->s_umount);
480 deactivate_super(sb);
481 return ERR_PTR(rc);
482 }
483 sb->s_flags |= MS_ACTIVE;
484 return sb;
485}
486
Steve French87c89dd2005-11-17 17:03:00 -0800487static ssize_t cifs_file_writev(struct file *file, const struct iovec *iov,
488 unsigned long nr_segs, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489{
Steve French87c89dd2005-11-17 17:03:00 -0800490 struct inode *inode = file->f_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 ssize_t written;
492
Steve French87c89dd2005-11-17 17:03:00 -0800493 written = generic_file_writev(file, iov, nr_segs, ppos);
494 if (!CIFS_I(inode)->clientCanCacheAll)
495 filemap_fdatawrite(inode->i_mapping);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 return written;
497}
498
Steve French87c89dd2005-11-17 17:03:00 -0800499static ssize_t cifs_file_aio_write(struct kiocb *iocb, const char __user *buf,
500 size_t count, loff_t pos)
501{
502 struct inode *inode = iocb->ki_filp->f_dentry->d_inode;
503 ssize_t written;
504
505 written = generic_file_aio_write(iocb, buf, count, pos);
506 if (!CIFS_I(inode)->clientCanCacheAll)
507 filemap_fdatawrite(inode->i_mapping);
508 return written;
509}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
Steve Frenchc32a0b62006-01-12 14:41:28 -0800511static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
512{
513 /* origin == SEEK_END => we must revalidate the cached file length */
514 if (origin == 2) {
515 int retval = cifs_revalidate(file->f_dentry);
516 if (retval < 0)
517 return (loff_t)retval;
518 }
519 return remote_llseek(file, offset, origin);
520}
521
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522static struct file_system_type cifs_fs_type = {
523 .owner = THIS_MODULE,
524 .name = "cifs",
525 .get_sb = cifs_get_sb,
526 .kill_sb = kill_anon_super,
527 /* .fs_flags */
528};
529struct inode_operations cifs_dir_inode_ops = {
530 .create = cifs_create,
531 .lookup = cifs_lookup,
532 .getattr = cifs_getattr,
533 .unlink = cifs_unlink,
534 .link = cifs_hardlink,
535 .mkdir = cifs_mkdir,
536 .rmdir = cifs_rmdir,
537 .rename = cifs_rename,
538 .permission = cifs_permission,
539/* revalidate:cifs_revalidate, */
540 .setattr = cifs_setattr,
541 .symlink = cifs_symlink,
542 .mknod = cifs_mknod,
543#ifdef CONFIG_CIFS_XATTR
544 .setxattr = cifs_setxattr,
545 .getxattr = cifs_getxattr,
546 .listxattr = cifs_listxattr,
547 .removexattr = cifs_removexattr,
548#endif
549};
550
551struct inode_operations cifs_file_inode_ops = {
552/* revalidate:cifs_revalidate, */
553 .setattr = cifs_setattr,
554 .getattr = cifs_getattr, /* do we need this anymore? */
555 .rename = cifs_rename,
556 .permission = cifs_permission,
557#ifdef CONFIG_CIFS_XATTR
558 .setxattr = cifs_setxattr,
559 .getxattr = cifs_getxattr,
560 .listxattr = cifs_listxattr,
561 .removexattr = cifs_removexattr,
562#endif
563};
564
565struct inode_operations cifs_symlink_inode_ops = {
566 .readlink = generic_readlink,
567 .follow_link = cifs_follow_link,
568 .put_link = cifs_put_link,
569 .permission = cifs_permission,
570 /* BB add the following two eventually */
571 /* revalidate: cifs_revalidate,
572 setattr: cifs_notify_change, *//* BB do we need notify change */
573#ifdef CONFIG_CIFS_XATTR
574 .setxattr = cifs_setxattr,
575 .getxattr = cifs_getxattr,
576 .listxattr = cifs_listxattr,
577 .removexattr = cifs_removexattr,
578#endif
579};
580
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800581const struct file_operations cifs_file_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800582 .read = do_sync_read,
583 .write = do_sync_write,
584 .readv = generic_file_readv,
585 .writev = cifs_file_writev,
586 .aio_read = generic_file_aio_read,
587 .aio_write = cifs_file_aio_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 .open = cifs_open,
589 .release = cifs_close,
590 .lock = cifs_lock,
591 .fsync = cifs_fsync,
592 .flush = cifs_flush,
593 .mmap = cifs_file_mmap,
594 .sendfile = generic_file_sendfile,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800595 .llseek = cifs_llseek,
Steve Frenchc67593a2005-04-28 22:41:04 -0700596#ifdef CONFIG_CIFS_POSIX
597 .ioctl = cifs_ioctl,
598#endif /* CONFIG_CIFS_POSIX */
599
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600#ifdef CONFIG_CIFS_EXPERIMENTAL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 .dir_notify = cifs_dir_notify,
602#endif /* CONFIG_CIFS_EXPERIMENTAL */
603};
604
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800605const struct file_operations cifs_file_direct_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 /* no mmap, no aio, no readv -
607 BB reevaluate whether they can be done with directio, no cache */
608 .read = cifs_user_read,
609 .write = cifs_user_write,
610 .open = cifs_open,
611 .release = cifs_close,
612 .lock = cifs_lock,
613 .fsync = cifs_fsync,
614 .flush = cifs_flush,
615 .sendfile = generic_file_sendfile, /* BB removeme BB */
Steve Frenchc67593a2005-04-28 22:41:04 -0700616#ifdef CONFIG_CIFS_POSIX
617 .ioctl = cifs_ioctl,
618#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800619 .llseek = cifs_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620#ifdef CONFIG_CIFS_EXPERIMENTAL
621 .dir_notify = cifs_dir_notify,
622#endif /* CONFIG_CIFS_EXPERIMENTAL */
623};
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800624const struct file_operations cifs_file_nobrl_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800625 .read = do_sync_read,
626 .write = do_sync_write,
627 .readv = generic_file_readv,
628 .writev = cifs_file_writev,
629 .aio_read = generic_file_aio_read,
630 .aio_write = cifs_file_aio_write,
631 .open = cifs_open,
632 .release = cifs_close,
633 .fsync = cifs_fsync,
634 .flush = cifs_flush,
635 .mmap = cifs_file_mmap,
636 .sendfile = generic_file_sendfile,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800637 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800638#ifdef CONFIG_CIFS_POSIX
Steve French87c89dd2005-11-17 17:03:00 -0800639 .ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800640#endif /* CONFIG_CIFS_POSIX */
641
642#ifdef CONFIG_CIFS_EXPERIMENTAL
Steve French87c89dd2005-11-17 17:03:00 -0800643 .dir_notify = cifs_dir_notify,
Steve French8b94bcb2005-11-11 11:41:00 -0800644#endif /* CONFIG_CIFS_EXPERIMENTAL */
645};
646
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800647const struct file_operations cifs_file_direct_nobrl_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800648 /* no mmap, no aio, no readv -
649 BB reevaluate whether they can be done with directio, no cache */
650 .read = cifs_user_read,
651 .write = cifs_user_write,
652 .open = cifs_open,
653 .release = cifs_close,
654 .fsync = cifs_fsync,
655 .flush = cifs_flush,
656 .sendfile = generic_file_sendfile, /* BB removeme BB */
Steve French8b94bcb2005-11-11 11:41:00 -0800657#ifdef CONFIG_CIFS_POSIX
Steve French87c89dd2005-11-17 17:03:00 -0800658 .ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800659#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800660 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800661#ifdef CONFIG_CIFS_EXPERIMENTAL
Steve French87c89dd2005-11-17 17:03:00 -0800662 .dir_notify = cifs_dir_notify,
Steve French8b94bcb2005-11-11 11:41:00 -0800663#endif /* CONFIG_CIFS_EXPERIMENTAL */
664};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800666const struct file_operations cifs_dir_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 .readdir = cifs_readdir,
668 .release = cifs_closedir,
669 .read = generic_read_dir,
670#ifdef CONFIG_CIFS_EXPERIMENTAL
671 .dir_notify = cifs_dir_notify,
672#endif /* CONFIG_CIFS_EXPERIMENTAL */
Steve Frenchf28ac912005-04-28 22:41:07 -0700673 .ioctl = cifs_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674};
675
676static void
677cifs_init_once(void *inode, kmem_cache_t * cachep, unsigned long flags)
678{
679 struct cifsInodeInfo *cifsi = inode;
680
681 if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
682 SLAB_CTOR_CONSTRUCTOR) {
683 inode_init_once(&cifsi->vfs_inode);
684 INIT_LIST_HEAD(&cifsi->lockList);
685 }
686}
687
688static int
689cifs_init_inodecache(void)
690{
691 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
692 sizeof (struct cifsInodeInfo),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800693 0, (SLAB_RECLAIM_ACCOUNT|
694 SLAB_MEM_SPREAD),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 cifs_init_once, NULL);
696 if (cifs_inode_cachep == NULL)
697 return -ENOMEM;
698
699 return 0;
700}
701
702static void
703cifs_destroy_inodecache(void)
704{
705 if (kmem_cache_destroy(cifs_inode_cachep))
706 printk(KERN_WARNING "cifs_inode_cache: error freeing\n");
707}
708
709static int
710cifs_init_request_bufs(void)
711{
712 if(CIFSMaxBufSize < 8192) {
713 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
714 Unicode path name has to fit in any SMB/CIFS path based frames */
715 CIFSMaxBufSize = 8192;
716 } else if (CIFSMaxBufSize > 1024*127) {
717 CIFSMaxBufSize = 1024 * 127;
718 } else {
719 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
720 }
721/* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
722 cifs_req_cachep = kmem_cache_create("cifs_request",
723 CIFSMaxBufSize +
724 MAX_CIFS_HDR_SIZE, 0,
725 SLAB_HWCACHE_ALIGN, NULL, NULL);
726 if (cifs_req_cachep == NULL)
727 return -ENOMEM;
728
729 if(cifs_min_rcv < 1)
730 cifs_min_rcv = 1;
731 else if (cifs_min_rcv > 64) {
732 cifs_min_rcv = 64;
733 cERROR(1,("cifs_min_rcv set to maximum (64)"));
734 }
735
Matthew Dobson93d23412006-03-26 01:37:50 -0800736 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
737 cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738
739 if(cifs_req_poolp == NULL) {
740 kmem_cache_destroy(cifs_req_cachep);
741 return -ENOMEM;
742 }
Steve Frenchec637e32005-12-12 20:53:18 -0800743 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 almost all handle based requests (but not write response, nor is it
745 sufficient for path based requests). A smaller size would have
746 been more efficient (compacting multiple slab items on one 4k page)
747 for the case in which debug was on, but this larger size allows
748 more SMBs to use small buffer alloc and is still much more
749 efficient to alloc 1 per page off the slab compared to 17K (5page)
750 alloc of large cifs buffers even when page debugging is on */
751 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
Steve Frenchec637e32005-12-12 20:53:18 -0800752 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
753 NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 if (cifs_sm_req_cachep == NULL) {
755 mempool_destroy(cifs_req_poolp);
756 kmem_cache_destroy(cifs_req_cachep);
757 return -ENOMEM;
758 }
759
760 if(cifs_min_small < 2)
761 cifs_min_small = 2;
762 else if (cifs_min_small > 256) {
763 cifs_min_small = 256;
764 cFYI(1,("cifs_min_small set to maximum (256)"));
765 }
766
Matthew Dobson93d23412006-03-26 01:37:50 -0800767 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
768 cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769
770 if(cifs_sm_req_poolp == NULL) {
771 mempool_destroy(cifs_req_poolp);
772 kmem_cache_destroy(cifs_req_cachep);
773 kmem_cache_destroy(cifs_sm_req_cachep);
774 return -ENOMEM;
775 }
776
777 return 0;
778}
779
780static void
781cifs_destroy_request_bufs(void)
782{
783 mempool_destroy(cifs_req_poolp);
784 if (kmem_cache_destroy(cifs_req_cachep))
785 printk(KERN_WARNING
786 "cifs_destroy_request_cache: error not all structures were freed\n");
787 mempool_destroy(cifs_sm_req_poolp);
788 if (kmem_cache_destroy(cifs_sm_req_cachep))
789 printk(KERN_WARNING
790 "cifs_destroy_request_cache: cifs_small_rq free error\n");
791}
792
793static int
794cifs_init_mids(void)
795{
796 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
797 sizeof (struct mid_q_entry), 0,
798 SLAB_HWCACHE_ALIGN, NULL, NULL);
799 if (cifs_mid_cachep == NULL)
800 return -ENOMEM;
801
Matthew Dobson93d23412006-03-26 01:37:50 -0800802 /* 3 is a reasonable minimum number of simultaneous operations */
803 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 if(cifs_mid_poolp == NULL) {
805 kmem_cache_destroy(cifs_mid_cachep);
806 return -ENOMEM;
807 }
808
809 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
810 sizeof (struct oplock_q_entry), 0,
811 SLAB_HWCACHE_ALIGN, NULL, NULL);
812 if (cifs_oplock_cachep == NULL) {
813 kmem_cache_destroy(cifs_mid_cachep);
814 mempool_destroy(cifs_mid_poolp);
815 return -ENOMEM;
816 }
817
818 return 0;
819}
820
821static void
822cifs_destroy_mids(void)
823{
824 mempool_destroy(cifs_mid_poolp);
825 if (kmem_cache_destroy(cifs_mid_cachep))
826 printk(KERN_WARNING
827 "cifs_destroy_mids: error not all structures were freed\n");
828
829 if (kmem_cache_destroy(cifs_oplock_cachep))
830 printk(KERN_WARNING
831 "error not all oplock structures were freed\n");
832}
833
834static int cifs_oplock_thread(void * dummyarg)
835{
836 struct oplock_q_entry * oplock_item;
837 struct cifsTconInfo *pTcon;
838 struct inode * inode;
839 __u16 netfid;
840 int rc;
841
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 do {
Steve Frenchede13272005-08-30 20:10:14 -0700843 if (try_to_freeze())
844 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 spin_lock(&GlobalMid_Lock);
847 if(list_empty(&GlobalOplock_Q)) {
848 spin_unlock(&GlobalMid_Lock);
849 set_current_state(TASK_INTERRUPTIBLE);
850 schedule_timeout(39*HZ);
851 } else {
852 oplock_item = list_entry(GlobalOplock_Q.next,
853 struct oplock_q_entry, qhead);
854 if(oplock_item) {
855 cFYI(1,("found oplock item to write out"));
856 pTcon = oplock_item->tcon;
857 inode = oplock_item->pinode;
858 netfid = oplock_item->netfid;
859 spin_unlock(&GlobalMid_Lock);
860 DeleteOplockQEntry(oplock_item);
861 /* can not grab inode sem here since it would
862 deadlock when oplock received on delete
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800863 since vfs_unlink holds the i_mutex across
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 the call */
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800865 /* mutex_lock(&inode->i_mutex);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 if (S_ISREG(inode->i_mode)) {
867 rc = filemap_fdatawrite(inode->i_mapping);
868 if(CIFS_I(inode)->clientCanCacheRead == 0) {
869 filemap_fdatawait(inode->i_mapping);
870 invalidate_remote_inode(inode);
871 }
872 } else
873 rc = 0;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800874 /* mutex_unlock(&inode->i_mutex);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 if (rc)
876 CIFS_I(inode)->write_behind_rc = rc;
877 cFYI(1,("Oplock flush inode %p rc %d",inode,rc));
878
879 /* releasing a stale oplock after recent reconnection
880 of smb session using a now incorrect file
881 handle is not a data integrity issue but do
882 not bother sending an oplock release if session
883 to server still is disconnected since oplock
884 already released by the server in that case */
885 if(pTcon->tidStatus != CifsNeedReconnect) {
886 rc = CIFSSMBLock(0, pTcon, netfid,
887 0 /* len */ , 0 /* offset */, 0,
888 0, LOCKING_ANDX_OPLOCK_RELEASE,
889 0 /* wait flag */);
890 cFYI(1,("Oplock release rc = %d ",rc));
891 }
892 } else
893 spin_unlock(&GlobalMid_Lock);
Steve French68058e72005-10-10 10:34:22 -0700894 set_current_state(TASK_INTERRUPTIBLE);
895 schedule_timeout(1); /* yield in case q were corrupt */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 }
Steve French45af7a02006-04-21 22:52:25 +0000897 } while (!kthread_should_stop());
898
899 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900}
901
Steve French8d0d5092005-08-18 09:41:43 -0700902static int cifs_dnotify_thread(void * dummyarg)
903{
Steve French6ab16d22005-11-29 20:55:11 -0800904 struct list_head *tmp;
905 struct cifsSesInfo *ses;
906
Steve French8d0d5092005-08-18 09:41:43 -0700907 do {
Steve French16abbec2005-08-30 13:10:14 -0700908 if(try_to_freeze())
909 continue;
Steve French8d0d5092005-08-18 09:41:43 -0700910 set_current_state(TASK_INTERRUPTIBLE);
Steve French6ab16d22005-11-29 20:55:11 -0800911 schedule_timeout(15*HZ);
912 read_lock(&GlobalSMBSeslock);
913 /* check if any stuck requests that need
914 to be woken up and wakeq so the
915 thread can wake up and error out */
916 list_for_each(tmp, &GlobalSMBSessionList) {
917 ses = list_entry(tmp, struct cifsSesInfo,
918 cifsSessionList);
919 if(ses && ses->server &&
Steve French2a138ebb2005-11-29 21:22:19 -0800920 atomic_read(&ses->server->inFlight))
Steve French6ab16d22005-11-29 20:55:11 -0800921 wake_up_all(&ses->server->response_q);
922 }
923 read_unlock(&GlobalSMBSeslock);
Steve French45af7a02006-04-21 22:52:25 +0000924 } while (!kthread_should_stop());
925
926 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927}
928
929static int __init
930init_cifs(void)
931{
932 int rc = 0;
933#ifdef CONFIG_PROC_FS
934 cifs_proc_init();
935#endif
936 INIT_LIST_HEAD(&GlobalServerList); /* BB not implemented yet */
937 INIT_LIST_HEAD(&GlobalSMBSessionList);
938 INIT_LIST_HEAD(&GlobalTreeConnectionList);
939 INIT_LIST_HEAD(&GlobalOplock_Q);
Steve French4ca9c192005-10-10 19:52:13 -0700940#ifdef CONFIG_CIFS_EXPERIMENTAL
941 INIT_LIST_HEAD(&GlobalDnotifyReqList);
942 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
943#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944/*
945 * Initialize Global counters
946 */
947 atomic_set(&sesInfoAllocCount, 0);
948 atomic_set(&tconInfoAllocCount, 0);
949 atomic_set(&tcpSesAllocCount,0);
950 atomic_set(&tcpSesReconnectCount, 0);
951 atomic_set(&tconInfoReconnectCount, 0);
952
953 atomic_set(&bufAllocCount, 0);
Steve French4498eed52005-12-03 13:58:57 -0800954 atomic_set(&smBufAllocCount, 0);
955#ifdef CONFIG_CIFS_STATS2
956 atomic_set(&totBufAllocCount, 0);
957 atomic_set(&totSmBufAllocCount, 0);
958#endif /* CONFIG_CIFS_STATS2 */
959
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 atomic_set(&midCount, 0);
961 GlobalCurrentXid = 0;
962 GlobalTotalActiveXid = 0;
963 GlobalMaxActiveXid = 0;
964 rwlock_init(&GlobalSMBSeslock);
965 spin_lock_init(&GlobalMid_Lock);
966
967 if(cifs_max_pending < 2) {
968 cifs_max_pending = 2;
969 cFYI(1,("cifs_max_pending set to min of 2"));
970 } else if(cifs_max_pending > 256) {
971 cifs_max_pending = 256;
972 cFYI(1,("cifs_max_pending set to max of 256"));
973 }
974
975 rc = cifs_init_inodecache();
Steve French45af7a02006-04-21 22:52:25 +0000976 if (rc)
977 goto out_clean_proc;
978
979 rc = cifs_init_mids();
980 if (rc)
981 goto out_destroy_inodecache;
982
983 rc = cifs_init_request_bufs();
984 if (rc)
985 goto out_destroy_mids;
986
987 rc = register_filesystem(&cifs_fs_type);
988 if (rc)
989 goto out_destroy_request_bufs;
990
991 oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
992 if (IS_ERR(oplockThread)) {
993 rc = PTR_ERR(oplockThread);
994 cERROR(1,("error %d create oplock thread", rc));
995 goto out_unregister_filesystem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 }
Steve French45af7a02006-04-21 22:52:25 +0000997
998 dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
999 if (IS_ERR(dnotifyThread)) {
1000 rc = PTR_ERR(dnotifyThread);
1001 cERROR(1,("error %d create dnotify thread", rc));
1002 goto out_stop_oplock_thread;
1003 }
1004
1005 return 0;
1006
1007 out_stop_oplock_thread:
1008 kthread_stop(oplockThread);
1009 out_unregister_filesystem:
1010 unregister_filesystem(&cifs_fs_type);
1011 out_destroy_request_bufs:
1012 cifs_destroy_request_bufs();
1013 out_destroy_mids:
1014 cifs_destroy_mids();
1015 out_destroy_inodecache:
1016 cifs_destroy_inodecache();
1017 out_clean_proc:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018#ifdef CONFIG_PROC_FS
1019 cifs_proc_clean();
1020#endif
1021 return rc;
1022}
1023
1024static void __exit
1025exit_cifs(void)
1026{
1027 cFYI(0, ("In unregister ie exit_cifs"));
1028#ifdef CONFIG_PROC_FS
1029 cifs_proc_clean();
1030#endif
1031 unregister_filesystem(&cifs_fs_type);
1032 cifs_destroy_inodecache();
1033 cifs_destroy_mids();
1034 cifs_destroy_request_bufs();
Steve French45af7a02006-04-21 22:52:25 +00001035 kthread_stop(oplockThread);
1036 kthread_stop(dnotifyThread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037}
1038
1039MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1040MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1041MODULE_DESCRIPTION
1042 ("VFS to access servers complying with the SNIA CIFS Specification e.g. Samba and Windows");
1043MODULE_VERSION(CIFS_VERSION);
1044module_init(init_cifs)
1045module_exit(exit_cifs)