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