blob: 8219c02145a7e8f1e619e4e3bf7cdee9d25b9251 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include "cifsfs.h"
37#include "cifspdu.h"
38#define DECLARE_GLOBALS_HERE
39#include "cifsglob.h"
40#include "cifsproto.h"
41#include "cifs_debug.h"
42#include "cifs_fs_sb.h"
43#include <linux/mm.h>
44#define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
45
46#ifdef CONFIG_CIFS_QUOTA
47static struct quotactl_ops cifs_quotactl_ops;
48#endif
49
50int cifsFYI = 0;
51int cifsERROR = 1;
52int traceSMB = 0;
53unsigned int oplockEnabled = 1;
54unsigned int experimEnabled = 0;
55unsigned int linuxExtEnabled = 1;
56unsigned int lookupCacheEnabled = 1;
57unsigned int multiuser_mount = 0;
58unsigned int extended_security = 0;
59unsigned int ntlmv2_support = 0;
60unsigned int sign_CIFS_PDUs = 1;
61extern struct task_struct * oplockThread; /* remove sparse warning */
62struct task_struct * oplockThread = NULL;
Steve French8d0d5092005-08-18 09:41:43 -070063extern struct task_struct * dnotifyThread; /* remove sparse warning */
64struct task_struct * dnotifyThread = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
66module_param(CIFSMaxBufSize, int, 0);
67MODULE_PARM_DESC(CIFSMaxBufSize,"Network buffer size (not including header). Default: 16384 Range: 8192 to 130048");
68unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
69module_param(cifs_min_rcv, int, 0);
70MODULE_PARM_DESC(cifs_min_rcv,"Network buffers in pool. Default: 4 Range: 1 to 64");
71unsigned int cifs_min_small = 30;
72module_param(cifs_min_small, int, 0);
73MODULE_PARM_DESC(cifs_min_small,"Small network buffers in pool. Default: 30 Range: 2 to 256");
74unsigned int cifs_max_pending = CIFS_MAX_REQ;
75module_param(cifs_max_pending, int, 0);
76MODULE_PARM_DESC(cifs_max_pending,"Simultaneous requests to server. Default: 50 Range: 2 to 256");
77
78static DECLARE_COMPLETION(cifs_oplock_exited);
Steve French8d0d5092005-08-18 09:41:43 -070079static DECLARE_COMPLETION(cifs_dnotify_exited);
Linus Torvalds1da177e2005-04-16 15:20:36 -070080
81extern mempool_t *cifs_sm_req_poolp;
82extern mempool_t *cifs_req_poolp;
83extern mempool_t *cifs_mid_poolp;
84
85extern kmem_cache_t *cifs_oplock_cachep;
86
87static int
88cifs_read_super(struct super_block *sb, void *data,
89 const char *devname, int silent)
90{
91 struct inode *inode;
92 struct cifs_sb_info *cifs_sb;
93 int rc = 0;
94
95 sb->s_flags |= MS_NODIRATIME; /* and probably even noatime */
Eric Sesterhenna048d7a2006-02-21 22:33:09 +000096 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info),GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 cifs_sb = CIFS_SB(sb);
98 if(cifs_sb == NULL)
99 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
101 rc = cifs_mount(sb, cifs_sb, data, devname);
102
103 if (rc) {
104 if (!silent)
105 cERROR(1,
106 ("cifs_mount failed w/return code = %d", rc));
107 goto out_mount_failed;
108 }
109
110 sb->s_magic = CIFS_MAGIC_NUMBER;
111 sb->s_op = &cifs_super_ops;
112/* if(cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
113 sb->s_blocksize = cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
114#ifdef CONFIG_CIFS_QUOTA
115 sb->s_qcop = &cifs_quotactl_ops;
116#endif
117 sb->s_blocksize = CIFS_MAX_MSGSIZE;
118 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
119 inode = iget(sb, ROOT_I);
120
121 if (!inode) {
122 rc = -ENOMEM;
123 goto out_no_root;
124 }
125
126 sb->s_root = d_alloc_root(inode);
127
128 if (!sb->s_root) {
129 rc = -ENOMEM;
130 goto out_no_root;
131 }
132
133 return 0;
134
135out_no_root:
136 cERROR(1, ("cifs_read_super: get root inode failed"));
137 if (inode)
138 iput(inode);
139
140out_mount_failed:
141 if(cifs_sb) {
142 if(cifs_sb->local_nls)
143 unload_nls(cifs_sb->local_nls);
144 kfree(cifs_sb);
145 }
146 return rc;
147}
148
149static void
150cifs_put_super(struct super_block *sb)
151{
152 int rc = 0;
153 struct cifs_sb_info *cifs_sb;
154
155 cFYI(1, ("In cifs_put_super"));
156 cifs_sb = CIFS_SB(sb);
157 if(cifs_sb == NULL) {
158 cFYI(1,("Empty cifs superblock info passed to unmount"));
159 return;
160 }
161 rc = cifs_umount(sb, cifs_sb);
162 if (rc) {
163 cERROR(1, ("cifs_umount failed with return code %d", rc));
164 }
165 unload_nls(cifs_sb->local_nls);
166 kfree(cifs_sb);
167 return;
168}
169
170static int
171cifs_statfs(struct super_block *sb, struct kstatfs *buf)
172{
Steve Frenchc81156d2005-04-28 22:41:07 -0700173 int xid;
174 int rc = -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 struct cifs_sb_info *cifs_sb;
176 struct cifsTconInfo *pTcon;
177
178 xid = GetXid();
179
180 cifs_sb = CIFS_SB(sb);
181 pTcon = cifs_sb->tcon;
182
183 buf->f_type = CIFS_MAGIC_NUMBER;
184
185 /* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */
Steve Frenchc81156d2005-04-28 22:41:07 -0700186 buf->f_namelen = PATH_MAX; /* PATH_MAX may be too long - it would
187 presumably be total path, but note
188 that some servers (includinng Samba 3)
189 have a shorter maximum path */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 buf->f_files = 0; /* undefined */
191 buf->f_ffree = 0; /* unlimited */
192
193#ifdef CONFIG_CIFS_EXPERIMENTAL
194/* BB we could add a second check for a QFS Unix capability bit */
Steve Frenchf28ac912005-04-28 22:41:07 -0700195/* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */
Steve Frenchc81156d2005-04-28 22:41:07 -0700196 if ((pTcon->ses->capabilities & CAP_UNIX) && (CIFS_POSIX_EXTENSIONS &
197 le64_to_cpu(pTcon->fsUnixInfo.Capability)))
Steve French737b7582005-04-28 22:41:06 -0700198 rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
200 /* Only need to call the old QFSInfo if failed
201 on newer one */
202 if(rc)
203#endif /* CIFS_EXPERIMENTAL */
Steve French737b7582005-04-28 22:41:06 -0700204 rc = CIFSSMBQFSInfo(xid, pTcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
Steve French20962432005-09-21 22:05:57 -0700206 /* Old Windows servers do not support level 103, retry with level
207 one if old server failed the previous call */
208 if(rc)
209 rc = SMBOldQFSInfo(xid, pTcon, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 /*
211 int f_type;
212 __fsid_t f_fsid;
213 int f_namelen; */
Steve Frenchc81156d2005-04-28 22:41:07 -0700214 /* BB get from info in tcon struct at mount time call to QFSAttrInfo */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 FreeXid(xid);
Steve Frenchc81156d2005-04-28 22:41:07 -0700216 return 0; /* always return success? what if volume is no
217 longer available? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218}
219
220static int cifs_permission(struct inode * inode, int mask, struct nameidata *nd)
221{
222 struct cifs_sb_info *cifs_sb;
223
224 cifs_sb = CIFS_SB(inode->i_sb);
225
226 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
227 return 0;
228 } else /* file mode might have been restricted at mount time
229 on the client (above and beyond ACL on servers) for
230 servers which do not support setting and viewing mode bits,
231 so allowing client to check permissions is useful */
232 return generic_permission(inode, mask, NULL);
233}
234
235static kmem_cache_t *cifs_inode_cachep;
236static kmem_cache_t *cifs_req_cachep;
237static kmem_cache_t *cifs_mid_cachep;
238kmem_cache_t *cifs_oplock_cachep;
239static kmem_cache_t *cifs_sm_req_cachep;
240mempool_t *cifs_sm_req_poolp;
241mempool_t *cifs_req_poolp;
242mempool_t *cifs_mid_poolp;
243
244static struct inode *
245cifs_alloc_inode(struct super_block *sb)
246{
247 struct cifsInodeInfo *cifs_inode;
248 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, SLAB_KERNEL);
249 if (!cifs_inode)
250 return NULL;
251 cifs_inode->cifsAttrs = 0x20; /* default */
252 atomic_set(&cifs_inode->inUse, 0);
253 cifs_inode->time = 0;
254 /* Until the file is open and we have gotten oplock
255 info back from the server, can not assume caching of
256 file data or metadata */
257 cifs_inode->clientCanCacheRead = FALSE;
258 cifs_inode->clientCanCacheAll = FALSE;
259 cifs_inode->vfs_inode.i_blksize = CIFS_MAX_MSGSIZE;
260 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
Steve Frenche30dcf32005-09-20 20:49:16 -0700261 cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 INIT_LIST_HEAD(&cifs_inode->openFileList);
263 return &cifs_inode->vfs_inode;
264}
265
266static void
267cifs_destroy_inode(struct inode *inode)
268{
269 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
270}
271
272/*
273 * cifs_show_options() is for displaying mount options in /proc/mounts.
274 * Not all settable options are displayed but most of the important
275 * ones are.
276 */
277static int
278cifs_show_options(struct seq_file *s, struct vfsmount *m)
279{
280 struct cifs_sb_info *cifs_sb;
281
282 cifs_sb = CIFS_SB(m->mnt_sb);
283
284 if (cifs_sb) {
285 if (cifs_sb->tcon) {
286 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
287 if (cifs_sb->tcon->ses) {
288 if (cifs_sb->tcon->ses->userName)
289 seq_printf(s, ",username=%s",
290 cifs_sb->tcon->ses->userName);
291 if(cifs_sb->tcon->ses->domainName)
292 seq_printf(s, ",domain=%s",
293 cifs_sb->tcon->ses->domainName);
294 }
295 }
296 seq_printf(s, ",rsize=%d",cifs_sb->rsize);
297 seq_printf(s, ",wsize=%d",cifs_sb->wsize);
298 }
299 return 0;
300}
301
302#ifdef CONFIG_CIFS_QUOTA
303int cifs_xquota_set(struct super_block * sb, int quota_type, qid_t qid,
304 struct fs_disk_quota * pdquota)
305{
306 int xid;
307 int rc = 0;
308 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
309 struct cifsTconInfo *pTcon;
310
311 if(cifs_sb)
312 pTcon = cifs_sb->tcon;
313 else
314 return -EIO;
315
316
317 xid = GetXid();
318 if(pTcon) {
319 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
320 } else {
321 return -EIO;
322 }
323
324 FreeXid(xid);
325 return rc;
326}
327
328int cifs_xquota_get(struct super_block * sb, int quota_type, qid_t qid,
329 struct fs_disk_quota * pdquota)
330{
331 int xid;
332 int rc = 0;
333 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
334 struct cifsTconInfo *pTcon;
335
336 if(cifs_sb)
337 pTcon = cifs_sb->tcon;
338 else
339 return -EIO;
340
341 xid = GetXid();
342 if(pTcon) {
343 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
344 } else {
345 rc = -EIO;
346 }
347
348 FreeXid(xid);
349 return rc;
350}
351
352int cifs_xstate_set(struct super_block * sb, unsigned int flags, int operation)
353{
354 int xid;
355 int rc = 0;
356 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
357 struct cifsTconInfo *pTcon;
358
359 if(cifs_sb)
360 pTcon = cifs_sb->tcon;
361 else
362 return -EIO;
363
364 xid = GetXid();
365 if(pTcon) {
366 cFYI(1,("flags: 0x%x operation: 0x%x",flags,operation));
367 } else {
368 rc = -EIO;
369 }
370
371 FreeXid(xid);
372 return rc;
373}
374
375int cifs_xstate_get(struct super_block * sb, struct fs_quota_stat *qstats)
376{
377 int xid;
378 int rc = 0;
379 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
380 struct cifsTconInfo *pTcon;
381
382 if(cifs_sb) {
383 pTcon = cifs_sb->tcon;
384 } else {
385 return -EIO;
386 }
387 xid = GetXid();
388 if(pTcon) {
389 cFYI(1,("pqstats %p",qstats));
390 } else {
391 rc = -EIO;
392 }
393
394 FreeXid(xid);
395 return rc;
396}
397
398static struct quotactl_ops cifs_quotactl_ops = {
399 .set_xquota = cifs_xquota_set,
400 .get_xquota = cifs_xquota_set,
401 .set_xstate = cifs_xstate_set,
402 .get_xstate = cifs_xstate_get,
403};
404#endif
405
Steve French7b7abfe2005-11-09 15:21:09 -0800406#ifdef CONFIG_CIFS_EXPERIMENTAL
Steve French68058e72005-10-10 10:34:22 -0700407static void cifs_umount_begin(struct super_block * sblock)
408{
Steve French5e1253b2005-10-10 14:06:37 -0700409 struct cifs_sb_info *cifs_sb;
Steve French9e2e85f2005-10-10 14:28:38 -0700410 struct cifsTconInfo * tcon;
Steve French68058e72005-10-10 10:34:22 -0700411
Steve French34210f32005-10-10 14:31:13 -0700412 cifs_sb = CIFS_SB(sblock);
Steve French5e1253b2005-10-10 14:06:37 -0700413 if(cifs_sb == NULL)
Steve French9e2e85f2005-10-10 14:28:38 -0700414 return;
415
416 tcon = cifs_sb->tcon;
417 if(tcon == NULL)
418 return;
Steve French5e1253b2005-10-10 14:06:37 -0700419 down(&tcon->tconSem);
420 if (atomic_read(&tcon->useCount) == 1)
421 tcon->tidStatus = CifsExiting;
422 up(&tcon->tconSem);
423
Steve French7b7abfe2005-11-09 15:21:09 -0800424 /* cancel_brl_requests(tcon); */
425 /* cancel_notify_requests(tcon); */
Steve French9e2e85f2005-10-10 14:28:38 -0700426 if(tcon->ses && tcon->ses->server)
Steve French5e1253b2005-10-10 14:06:37 -0700427 {
Steve French7b7abfe2005-11-09 15:21:09 -0800428 cFYI(1,("wake up tasks now - umount begin not complete"));
Steve French9e2e85f2005-10-10 14:28:38 -0700429 wake_up_all(&tcon->ses->server->request_q);
Steve French6ab16d22005-11-29 20:55:11 -0800430 wake_up_all(&tcon->ses->server->response_q);
431 msleep(1); /* yield */
432 /* we have to kick the requests once more */
433 wake_up_all(&tcon->ses->server->response_q);
434 msleep(1);
Steve French5e1253b2005-10-10 14:06:37 -0700435 }
436/* BB FIXME - finish add checks for tidStatus BB */
Steve French68058e72005-10-10 10:34:22 -0700437
438 return;
439}
Steve French7b7abfe2005-11-09 15:21:09 -0800440#endif
Steve French68058e72005-10-10 10:34:22 -0700441
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442static int cifs_remount(struct super_block *sb, int *flags, char *data)
443{
444 *flags |= MS_NODIRATIME;
445 return 0;
446}
447
448struct super_operations cifs_super_ops = {
449 .read_inode = cifs_read_inode,
450 .put_super = cifs_put_super,
451 .statfs = cifs_statfs,
452 .alloc_inode = cifs_alloc_inode,
453 .destroy_inode = cifs_destroy_inode,
454/* .drop_inode = generic_delete_inode,
455 .delete_inode = cifs_delete_inode, *//* Do not need the above two functions
456 unless later we add lazy close of inodes or unless the kernel forgets to call
457 us with the same number of releases (closes) as opens */
458 .show_options = cifs_show_options,
Steve French7b7abfe2005-11-09 15:21:09 -0800459#ifdef CONFIG_CIFS_EXPERIMENTAL
460 .umount_begin = cifs_umount_begin,
461#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 .remount_fs = cifs_remount,
463};
464
465static struct super_block *
466cifs_get_sb(struct file_system_type *fs_type,
467 int flags, const char *dev_name, void *data)
468{
469 int rc;
470 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
471
472 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
473
474 if (IS_ERR(sb))
475 return sb;
476
477 sb->s_flags = flags;
478
479 rc = cifs_read_super(sb, data, dev_name, flags & MS_VERBOSE ? 1 : 0);
480 if (rc) {
481 up_write(&sb->s_umount);
482 deactivate_super(sb);
483 return ERR_PTR(rc);
484 }
485 sb->s_flags |= MS_ACTIVE;
486 return sb;
487}
488
Steve French87c89dd2005-11-17 17:03:00 -0800489static ssize_t cifs_file_writev(struct file *file, const struct iovec *iov,
490 unsigned long nr_segs, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491{
Steve French87c89dd2005-11-17 17:03:00 -0800492 struct inode *inode = file->f_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 ssize_t written;
494
Steve French87c89dd2005-11-17 17:03:00 -0800495 written = generic_file_writev(file, iov, nr_segs, ppos);
496 if (!CIFS_I(inode)->clientCanCacheAll)
497 filemap_fdatawrite(inode->i_mapping);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 return written;
499}
500
Steve French87c89dd2005-11-17 17:03:00 -0800501static ssize_t cifs_file_aio_write(struct kiocb *iocb, const char __user *buf,
502 size_t count, loff_t pos)
503{
504 struct inode *inode = iocb->ki_filp->f_dentry->d_inode;
505 ssize_t written;
506
507 written = generic_file_aio_write(iocb, buf, count, pos);
508 if (!CIFS_I(inode)->clientCanCacheAll)
509 filemap_fdatawrite(inode->i_mapping);
510 return written;
511}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
Steve Frenchc32a0b62006-01-12 14:41:28 -0800513static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
514{
515 /* origin == SEEK_END => we must revalidate the cached file length */
516 if (origin == 2) {
517 int retval = cifs_revalidate(file->f_dentry);
518 if (retval < 0)
519 return (loff_t)retval;
520 }
521 return remote_llseek(file, offset, origin);
522}
523
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524static struct file_system_type cifs_fs_type = {
525 .owner = THIS_MODULE,
526 .name = "cifs",
527 .get_sb = cifs_get_sb,
528 .kill_sb = kill_anon_super,
529 /* .fs_flags */
530};
531struct inode_operations cifs_dir_inode_ops = {
532 .create = cifs_create,
533 .lookup = cifs_lookup,
534 .getattr = cifs_getattr,
535 .unlink = cifs_unlink,
536 .link = cifs_hardlink,
537 .mkdir = cifs_mkdir,
538 .rmdir = cifs_rmdir,
539 .rename = cifs_rename,
540 .permission = cifs_permission,
541/* revalidate:cifs_revalidate, */
542 .setattr = cifs_setattr,
543 .symlink = cifs_symlink,
544 .mknod = cifs_mknod,
545#ifdef CONFIG_CIFS_XATTR
546 .setxattr = cifs_setxattr,
547 .getxattr = cifs_getxattr,
548 .listxattr = cifs_listxattr,
549 .removexattr = cifs_removexattr,
550#endif
551};
552
553struct inode_operations cifs_file_inode_ops = {
554/* revalidate:cifs_revalidate, */
555 .setattr = cifs_setattr,
556 .getattr = cifs_getattr, /* do we need this anymore? */
557 .rename = cifs_rename,
558 .permission = cifs_permission,
559#ifdef CONFIG_CIFS_XATTR
560 .setxattr = cifs_setxattr,
561 .getxattr = cifs_getxattr,
562 .listxattr = cifs_listxattr,
563 .removexattr = cifs_removexattr,
564#endif
565};
566
567struct inode_operations cifs_symlink_inode_ops = {
568 .readlink = generic_readlink,
569 .follow_link = cifs_follow_link,
570 .put_link = cifs_put_link,
571 .permission = cifs_permission,
572 /* BB add the following two eventually */
573 /* revalidate: cifs_revalidate,
574 setattr: cifs_notify_change, *//* BB do we need notify change */
575#ifdef CONFIG_CIFS_XATTR
576 .setxattr = cifs_setxattr,
577 .getxattr = cifs_getxattr,
578 .listxattr = cifs_listxattr,
579 .removexattr = cifs_removexattr,
580#endif
581};
582
583struct file_operations cifs_file_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800584 .read = do_sync_read,
585 .write = do_sync_write,
586 .readv = generic_file_readv,
587 .writev = cifs_file_writev,
588 .aio_read = generic_file_aio_read,
589 .aio_write = cifs_file_aio_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 .open = cifs_open,
591 .release = cifs_close,
592 .lock = cifs_lock,
593 .fsync = cifs_fsync,
594 .flush = cifs_flush,
595 .mmap = cifs_file_mmap,
596 .sendfile = generic_file_sendfile,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800597 .llseek = cifs_llseek,
Steve Frenchc67593a2005-04-28 22:41:04 -0700598#ifdef CONFIG_CIFS_POSIX
599 .ioctl = cifs_ioctl,
600#endif /* CONFIG_CIFS_POSIX */
601
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602#ifdef CONFIG_CIFS_EXPERIMENTAL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 .dir_notify = cifs_dir_notify,
604#endif /* CONFIG_CIFS_EXPERIMENTAL */
605};
606
607struct file_operations cifs_file_direct_ops = {
608 /* no mmap, no aio, no readv -
609 BB reevaluate whether they can be done with directio, no cache */
610 .read = cifs_user_read,
611 .write = cifs_user_write,
612 .open = cifs_open,
613 .release = cifs_close,
614 .lock = cifs_lock,
615 .fsync = cifs_fsync,
616 .flush = cifs_flush,
617 .sendfile = generic_file_sendfile, /* BB removeme BB */
Steve Frenchc67593a2005-04-28 22:41:04 -0700618#ifdef CONFIG_CIFS_POSIX
619 .ioctl = cifs_ioctl,
620#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800621 .llseek = cifs_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622#ifdef CONFIG_CIFS_EXPERIMENTAL
623 .dir_notify = cifs_dir_notify,
624#endif /* CONFIG_CIFS_EXPERIMENTAL */
625};
Steve French8b94bcb2005-11-11 11:41:00 -0800626struct file_operations cifs_file_nobrl_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800627 .read = do_sync_read,
628 .write = do_sync_write,
629 .readv = generic_file_readv,
630 .writev = cifs_file_writev,
631 .aio_read = generic_file_aio_read,
632 .aio_write = cifs_file_aio_write,
633 .open = cifs_open,
634 .release = cifs_close,
635 .fsync = cifs_fsync,
636 .flush = cifs_flush,
637 .mmap = cifs_file_mmap,
638 .sendfile = generic_file_sendfile,
Steve Frenchc32a0b62006-01-12 14:41:28 -0800639 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800640#ifdef CONFIG_CIFS_POSIX
Steve French87c89dd2005-11-17 17:03:00 -0800641 .ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800642#endif /* CONFIG_CIFS_POSIX */
643
644#ifdef CONFIG_CIFS_EXPERIMENTAL
Steve French87c89dd2005-11-17 17:03:00 -0800645 .dir_notify = cifs_dir_notify,
Steve French8b94bcb2005-11-11 11:41:00 -0800646#endif /* CONFIG_CIFS_EXPERIMENTAL */
647};
648
649struct file_operations cifs_file_direct_nobrl_ops = {
Steve French87c89dd2005-11-17 17:03:00 -0800650 /* no mmap, no aio, no readv -
651 BB reevaluate whether they can be done with directio, no cache */
652 .read = cifs_user_read,
653 .write = cifs_user_write,
654 .open = cifs_open,
655 .release = cifs_close,
656 .fsync = cifs_fsync,
657 .flush = cifs_flush,
658 .sendfile = generic_file_sendfile, /* BB removeme BB */
Steve French8b94bcb2005-11-11 11:41:00 -0800659#ifdef CONFIG_CIFS_POSIX
Steve French87c89dd2005-11-17 17:03:00 -0800660 .ioctl = cifs_ioctl,
Steve French8b94bcb2005-11-11 11:41:00 -0800661#endif /* CONFIG_CIFS_POSIX */
Steve Frenchc32a0b62006-01-12 14:41:28 -0800662 .llseek = cifs_llseek,
Steve French8b94bcb2005-11-11 11:41:00 -0800663#ifdef CONFIG_CIFS_EXPERIMENTAL
Steve French87c89dd2005-11-17 17:03:00 -0800664 .dir_notify = cifs_dir_notify,
Steve French8b94bcb2005-11-11 11:41:00 -0800665#endif /* CONFIG_CIFS_EXPERIMENTAL */
666};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667
668struct file_operations cifs_dir_ops = {
669 .readdir = cifs_readdir,
670 .release = cifs_closedir,
671 .read = generic_read_dir,
672#ifdef CONFIG_CIFS_EXPERIMENTAL
673 .dir_notify = cifs_dir_notify,
674#endif /* CONFIG_CIFS_EXPERIMENTAL */
Steve Frenchf28ac912005-04-28 22:41:07 -0700675 .ioctl = cifs_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676};
677
678static void
679cifs_init_once(void *inode, kmem_cache_t * cachep, unsigned long flags)
680{
681 struct cifsInodeInfo *cifsi = inode;
682
683 if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
684 SLAB_CTOR_CONSTRUCTOR) {
685 inode_init_once(&cifsi->vfs_inode);
686 INIT_LIST_HEAD(&cifsi->lockList);
687 }
688}
689
690static int
691cifs_init_inodecache(void)
692{
693 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
694 sizeof (struct cifsInodeInfo),
695 0, SLAB_RECLAIM_ACCOUNT,
696 cifs_init_once, NULL);
697 if (cifs_inode_cachep == NULL)
698 return -ENOMEM;
699
700 return 0;
701}
702
703static void
704cifs_destroy_inodecache(void)
705{
706 if (kmem_cache_destroy(cifs_inode_cachep))
707 printk(KERN_WARNING "cifs_inode_cache: error freeing\n");
708}
709
710static int
711cifs_init_request_bufs(void)
712{
713 if(CIFSMaxBufSize < 8192) {
714 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
715 Unicode path name has to fit in any SMB/CIFS path based frames */
716 CIFSMaxBufSize = 8192;
717 } else if (CIFSMaxBufSize > 1024*127) {
718 CIFSMaxBufSize = 1024 * 127;
719 } else {
720 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
721 }
722/* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
723 cifs_req_cachep = kmem_cache_create("cifs_request",
724 CIFSMaxBufSize +
725 MAX_CIFS_HDR_SIZE, 0,
726 SLAB_HWCACHE_ALIGN, NULL, NULL);
727 if (cifs_req_cachep == NULL)
728 return -ENOMEM;
729
730 if(cifs_min_rcv < 1)
731 cifs_min_rcv = 1;
732 else if (cifs_min_rcv > 64) {
733 cifs_min_rcv = 64;
734 cERROR(1,("cifs_min_rcv set to maximum (64)"));
735 }
736
737 cifs_req_poolp = mempool_create(cifs_min_rcv,
738 mempool_alloc_slab,
739 mempool_free_slab,
740 cifs_req_cachep);
741
742 if(cifs_req_poolp == NULL) {
743 kmem_cache_destroy(cifs_req_cachep);
744 return -ENOMEM;
745 }
Steve Frenchec637e32005-12-12 20:53:18 -0800746 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 almost all handle based requests (but not write response, nor is it
748 sufficient for path based requests). A smaller size would have
749 been more efficient (compacting multiple slab items on one 4k page)
750 for the case in which debug was on, but this larger size allows
751 more SMBs to use small buffer alloc and is still much more
752 efficient to alloc 1 per page off the slab compared to 17K (5page)
753 alloc of large cifs buffers even when page debugging is on */
754 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
Steve Frenchec637e32005-12-12 20:53:18 -0800755 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
756 NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 if (cifs_sm_req_cachep == NULL) {
758 mempool_destroy(cifs_req_poolp);
759 kmem_cache_destroy(cifs_req_cachep);
760 return -ENOMEM;
761 }
762
763 if(cifs_min_small < 2)
764 cifs_min_small = 2;
765 else if (cifs_min_small > 256) {
766 cifs_min_small = 256;
767 cFYI(1,("cifs_min_small set to maximum (256)"));
768 }
769
770 cifs_sm_req_poolp = mempool_create(cifs_min_small,
771 mempool_alloc_slab,
772 mempool_free_slab,
773 cifs_sm_req_cachep);
774
775 if(cifs_sm_req_poolp == NULL) {
776 mempool_destroy(cifs_req_poolp);
777 kmem_cache_destroy(cifs_req_cachep);
778 kmem_cache_destroy(cifs_sm_req_cachep);
779 return -ENOMEM;
780 }
781
782 return 0;
783}
784
785static void
786cifs_destroy_request_bufs(void)
787{
788 mempool_destroy(cifs_req_poolp);
789 if (kmem_cache_destroy(cifs_req_cachep))
790 printk(KERN_WARNING
791 "cifs_destroy_request_cache: error not all structures were freed\n");
792 mempool_destroy(cifs_sm_req_poolp);
793 if (kmem_cache_destroy(cifs_sm_req_cachep))
794 printk(KERN_WARNING
795 "cifs_destroy_request_cache: cifs_small_rq free error\n");
796}
797
798static int
799cifs_init_mids(void)
800{
801 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
802 sizeof (struct mid_q_entry), 0,
803 SLAB_HWCACHE_ALIGN, NULL, NULL);
804 if (cifs_mid_cachep == NULL)
805 return -ENOMEM;
806
807 cifs_mid_poolp = mempool_create(3 /* a reasonable min simultan opers */,
808 mempool_alloc_slab,
809 mempool_free_slab,
810 cifs_mid_cachep);
811 if(cifs_mid_poolp == NULL) {
812 kmem_cache_destroy(cifs_mid_cachep);
813 return -ENOMEM;
814 }
815
816 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
817 sizeof (struct oplock_q_entry), 0,
818 SLAB_HWCACHE_ALIGN, NULL, NULL);
819 if (cifs_oplock_cachep == NULL) {
820 kmem_cache_destroy(cifs_mid_cachep);
821 mempool_destroy(cifs_mid_poolp);
822 return -ENOMEM;
823 }
824
825 return 0;
826}
827
828static void
829cifs_destroy_mids(void)
830{
831 mempool_destroy(cifs_mid_poolp);
832 if (kmem_cache_destroy(cifs_mid_cachep))
833 printk(KERN_WARNING
834 "cifs_destroy_mids: error not all structures were freed\n");
835
836 if (kmem_cache_destroy(cifs_oplock_cachep))
837 printk(KERN_WARNING
838 "error not all oplock structures were freed\n");
839}
840
841static int cifs_oplock_thread(void * dummyarg)
842{
843 struct oplock_q_entry * oplock_item;
844 struct cifsTconInfo *pTcon;
845 struct inode * inode;
846 __u16 netfid;
847 int rc;
848
849 daemonize("cifsoplockd");
850 allow_signal(SIGTERM);
851
852 oplockThread = current;
853 do {
Steve Frenchede13272005-08-30 20:10:14 -0700854 if (try_to_freeze())
855 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 spin_lock(&GlobalMid_Lock);
858 if(list_empty(&GlobalOplock_Q)) {
859 spin_unlock(&GlobalMid_Lock);
860 set_current_state(TASK_INTERRUPTIBLE);
861 schedule_timeout(39*HZ);
862 } else {
863 oplock_item = list_entry(GlobalOplock_Q.next,
864 struct oplock_q_entry, qhead);
865 if(oplock_item) {
866 cFYI(1,("found oplock item to write out"));
867 pTcon = oplock_item->tcon;
868 inode = oplock_item->pinode;
869 netfid = oplock_item->netfid;
870 spin_unlock(&GlobalMid_Lock);
871 DeleteOplockQEntry(oplock_item);
872 /* can not grab inode sem here since it would
873 deadlock when oplock received on delete
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800874 since vfs_unlink holds the i_mutex across
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 the call */
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800876 /* mutex_lock(&inode->i_mutex);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 if (S_ISREG(inode->i_mode)) {
878 rc = filemap_fdatawrite(inode->i_mapping);
879 if(CIFS_I(inode)->clientCanCacheRead == 0) {
880 filemap_fdatawait(inode->i_mapping);
881 invalidate_remote_inode(inode);
882 }
883 } else
884 rc = 0;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800885 /* mutex_unlock(&inode->i_mutex);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 if (rc)
887 CIFS_I(inode)->write_behind_rc = rc;
888 cFYI(1,("Oplock flush inode %p rc %d",inode,rc));
889
890 /* releasing a stale oplock after recent reconnection
891 of smb session using a now incorrect file
892 handle is not a data integrity issue but do
893 not bother sending an oplock release if session
894 to server still is disconnected since oplock
895 already released by the server in that case */
896 if(pTcon->tidStatus != CifsNeedReconnect) {
897 rc = CIFSSMBLock(0, pTcon, netfid,
898 0 /* len */ , 0 /* offset */, 0,
899 0, LOCKING_ANDX_OPLOCK_RELEASE,
900 0 /* wait flag */);
901 cFYI(1,("Oplock release rc = %d ",rc));
902 }
903 } else
904 spin_unlock(&GlobalMid_Lock);
Steve French68058e72005-10-10 10:34:22 -0700905 set_current_state(TASK_INTERRUPTIBLE);
906 schedule_timeout(1); /* yield in case q were corrupt */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 }
908 } while(!signal_pending(current));
Steve French57337e42005-04-28 22:41:10 -0700909 oplockThread = NULL;
Steve Frenchf1914012005-08-18 09:37:34 -0700910 complete_and_exit (&cifs_oplock_exited, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911}
912
Steve French8d0d5092005-08-18 09:41:43 -0700913static int cifs_dnotify_thread(void * dummyarg)
914{
Steve French6ab16d22005-11-29 20:55:11 -0800915 struct list_head *tmp;
916 struct cifsSesInfo *ses;
917
Steve French8d0d5092005-08-18 09:41:43 -0700918 daemonize("cifsdnotifyd");
919 allow_signal(SIGTERM);
920
921 dnotifyThread = current;
922 do {
Steve French16abbec2005-08-30 13:10:14 -0700923 if(try_to_freeze())
924 continue;
Steve French8d0d5092005-08-18 09:41:43 -0700925 set_current_state(TASK_INTERRUPTIBLE);
Steve French6ab16d22005-11-29 20:55:11 -0800926 schedule_timeout(15*HZ);
927 read_lock(&GlobalSMBSeslock);
928 /* check if any stuck requests that need
929 to be woken up and wakeq so the
930 thread can wake up and error out */
931 list_for_each(tmp, &GlobalSMBSessionList) {
932 ses = list_entry(tmp, struct cifsSesInfo,
933 cifsSessionList);
934 if(ses && ses->server &&
Steve French2a138ebb2005-11-29 21:22:19 -0800935 atomic_read(&ses->server->inFlight))
Steve French6ab16d22005-11-29 20:55:11 -0800936 wake_up_all(&ses->server->response_q);
937 }
938 read_unlock(&GlobalSMBSeslock);
Steve French8d0d5092005-08-18 09:41:43 -0700939 } while(!signal_pending(current));
940 complete_and_exit (&cifs_dnotify_exited, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941}
942
943static int __init
944init_cifs(void)
945{
946 int rc = 0;
947#ifdef CONFIG_PROC_FS
948 cifs_proc_init();
949#endif
950 INIT_LIST_HEAD(&GlobalServerList); /* BB not implemented yet */
951 INIT_LIST_HEAD(&GlobalSMBSessionList);
952 INIT_LIST_HEAD(&GlobalTreeConnectionList);
953 INIT_LIST_HEAD(&GlobalOplock_Q);
Steve French4ca9c192005-10-10 19:52:13 -0700954#ifdef CONFIG_CIFS_EXPERIMENTAL
955 INIT_LIST_HEAD(&GlobalDnotifyReqList);
956 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
957#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958/*
959 * Initialize Global counters
960 */
961 atomic_set(&sesInfoAllocCount, 0);
962 atomic_set(&tconInfoAllocCount, 0);
963 atomic_set(&tcpSesAllocCount,0);
964 atomic_set(&tcpSesReconnectCount, 0);
965 atomic_set(&tconInfoReconnectCount, 0);
966
967 atomic_set(&bufAllocCount, 0);
Steve French4498eed52005-12-03 13:58:57 -0800968 atomic_set(&smBufAllocCount, 0);
969#ifdef CONFIG_CIFS_STATS2
970 atomic_set(&totBufAllocCount, 0);
971 atomic_set(&totSmBufAllocCount, 0);
972#endif /* CONFIG_CIFS_STATS2 */
973
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 atomic_set(&midCount, 0);
975 GlobalCurrentXid = 0;
976 GlobalTotalActiveXid = 0;
977 GlobalMaxActiveXid = 0;
978 rwlock_init(&GlobalSMBSeslock);
979 spin_lock_init(&GlobalMid_Lock);
980
981 if(cifs_max_pending < 2) {
982 cifs_max_pending = 2;
983 cFYI(1,("cifs_max_pending set to min of 2"));
984 } else if(cifs_max_pending > 256) {
985 cifs_max_pending = 256;
986 cFYI(1,("cifs_max_pending set to max of 256"));
987 }
988
989 rc = cifs_init_inodecache();
990 if (!rc) {
991 rc = cifs_init_mids();
992 if (!rc) {
993 rc = cifs_init_request_bufs();
994 if (!rc) {
995 rc = register_filesystem(&cifs_fs_type);
996 if (!rc) {
997 rc = (int)kernel_thread(cifs_oplock_thread, NULL,
998 CLONE_FS | CLONE_FILES | CLONE_VM);
Steve French8d0d5092005-08-18 09:41:43 -0700999 if(rc > 0) {
1000 rc = (int)kernel_thread(cifs_dnotify_thread, NULL,
1001 CLONE_FS | CLONE_FILES | CLONE_VM);
1002 if(rc > 0)
1003 return 0;
1004 else
1005 cERROR(1,("error %d create dnotify thread", rc));
1006 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 cERROR(1,("error %d create oplock thread",rc));
Steve French8d0d5092005-08-18 09:41:43 -07001008 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 }
1010 cifs_destroy_request_bufs();
1011 }
1012 cifs_destroy_mids();
1013 }
1014 cifs_destroy_inodecache();
1015 }
1016#ifdef CONFIG_PROC_FS
1017 cifs_proc_clean();
1018#endif
1019 return rc;
1020}
1021
1022static void __exit
1023exit_cifs(void)
1024{
1025 cFYI(0, ("In unregister ie exit_cifs"));
1026#ifdef CONFIG_PROC_FS
1027 cifs_proc_clean();
1028#endif
1029 unregister_filesystem(&cifs_fs_type);
1030 cifs_destroy_inodecache();
1031 cifs_destroy_mids();
1032 cifs_destroy_request_bufs();
1033 if(oplockThread) {
1034 send_sig(SIGTERM, oplockThread, 1);
1035 wait_for_completion(&cifs_oplock_exited);
1036 }
Steve French8d0d5092005-08-18 09:41:43 -07001037 if(dnotifyThread) {
1038 send_sig(SIGTERM, dnotifyThread, 1);
1039 wait_for_completion(&cifs_dnotify_exited);
1040 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041}
1042
1043MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1044MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1045MODULE_DESCRIPTION
1046 ("VFS to access servers complying with the SNIA CIFS Specification e.g. Samba and Windows");
1047MODULE_VERSION(CIFS_VERSION);
1048module_init(init_cifs)
1049module_exit(exit_cifs)