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