Merge git://git.kernel.org/pub/scm/linux/kernel/git/sfrench/cifs-2.6
[sfrench/cifs-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 <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 #ifdef CONFIG_CIFS_EXPERIMENTAL
406 static void cifs_umount_begin(struct vfsmount * vfsmnt, int flags)
407 {
408         struct cifs_sb_info *cifs_sb;
409         struct cifsTconInfo * tcon;
410
411         if (!(flags & MNT_FORCE))
412                 return;
413         cifs_sb = CIFS_SB(vfsmnt->mnt_sb);
414         if(cifs_sb == NULL)
415                 return;
416
417         tcon = cifs_sb->tcon;
418         if(tcon == NULL)
419                 return;
420         down(&tcon->tconSem);
421         if (atomic_read(&tcon->useCount) == 1)
422                 tcon->tidStatus = CifsExiting;
423         up(&tcon->tconSem);
424
425         /* cancel_brl_requests(tcon); */
426         /* cancel_notify_requests(tcon); */
427         if(tcon->ses && tcon->ses->server)
428         {
429                 cFYI(1,("wake up tasks now - umount begin not complete"));
430                 wake_up_all(&tcon->ses->server->request_q);
431                 wake_up_all(&tcon->ses->server->response_q);
432                 msleep(1); /* yield */
433                 /* we have to kick the requests once more */
434                 wake_up_all(&tcon->ses->server->response_q);
435                 msleep(1);
436         }
437 /* BB FIXME - finish add checks for tidStatus BB */
438
439         return;
440 }
441 #endif  
442
443 static int cifs_remount(struct super_block *sb, int *flags, char *data)
444 {
445         *flags |= MS_NODIRATIME;
446         return 0;
447 }
448
449 struct super_operations cifs_super_ops = {
450         .read_inode = cifs_read_inode,
451         .put_super = cifs_put_super,
452         .statfs = cifs_statfs,
453         .alloc_inode = cifs_alloc_inode,
454         .destroy_inode = cifs_destroy_inode,
455 /*      .drop_inode         = generic_delete_inode, 
456         .delete_inode   = cifs_delete_inode,  *//* Do not need the above two functions     
457    unless later we add lazy close of inodes or unless the kernel forgets to call
458    us with the same number of releases (closes) as opens */
459         .show_options = cifs_show_options,
460 #ifdef CONFIG_CIFS_EXPERIMENTAL
461         .umount_begin   = cifs_umount_begin,
462 #endif
463         .remount_fs = cifs_remount,
464 };
465
466 static int
467 cifs_get_sb(struct file_system_type *fs_type,
468             int flags, const char *dev_name, void *data, struct vfsmount *mnt)
469 {
470         int rc;
471         struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
472
473         cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
474
475         if (IS_ERR(sb))
476                 return PTR_ERR(sb);
477
478         sb->s_flags = flags;
479
480         rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
481         if (rc) {
482                 up_write(&sb->s_umount);
483                 deactivate_super(sb);
484                 return rc;
485         }
486         sb->s_flags |= MS_ACTIVE;
487         return simple_set_mnt(mnt, sb);
488 }
489
490 static ssize_t cifs_file_writev(struct file *file, const struct iovec *iov,
491                                 unsigned long nr_segs, loff_t *ppos)
492 {
493         struct inode *inode = file->f_dentry->d_inode;
494         ssize_t written;
495
496         written = generic_file_writev(file, iov, nr_segs, ppos);
497         if (!CIFS_I(inode)->clientCanCacheAll)
498                 filemap_fdatawrite(inode->i_mapping);
499         return written;
500 }
501
502 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const char __user *buf,
503                                    size_t count, loff_t pos)
504 {
505         struct inode *inode = iocb->ki_filp->f_dentry->d_inode;
506         ssize_t written;
507
508         written = generic_file_aio_write(iocb, buf, count, pos);
509         if (!CIFS_I(inode)->clientCanCacheAll)
510                 filemap_fdatawrite(inode->i_mapping);
511         return written;
512 }
513
514 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
515 {
516         /* origin == SEEK_END => we must revalidate the cached file length */
517         if (origin == 2) {
518                 int retval = cifs_revalidate(file->f_dentry);
519                 if (retval < 0)
520                         return (loff_t)retval;
521         }
522         return remote_llseek(file, offset, origin);
523 }
524
525 static struct file_system_type cifs_fs_type = {
526         .owner = THIS_MODULE,
527         .name = "cifs",
528         .get_sb = cifs_get_sb,
529         .kill_sb = kill_anon_super,
530         /*  .fs_flags */
531 };
532 struct inode_operations cifs_dir_inode_ops = {
533         .create = cifs_create,
534         .lookup = cifs_lookup,
535         .getattr = cifs_getattr,
536         .unlink = cifs_unlink,
537         .link = cifs_hardlink,
538         .mkdir = cifs_mkdir,
539         .rmdir = cifs_rmdir,
540         .rename = cifs_rename,
541         .permission = cifs_permission,
542 /*      revalidate:cifs_revalidate,   */
543         .setattr = cifs_setattr,
544         .symlink = cifs_symlink,
545         .mknod   = cifs_mknod,
546 #ifdef CONFIG_CIFS_XATTR
547         .setxattr = cifs_setxattr,
548         .getxattr = cifs_getxattr,
549         .listxattr = cifs_listxattr,
550         .removexattr = cifs_removexattr,
551 #endif
552 };
553
554 struct inode_operations cifs_file_inode_ops = {
555 /*      revalidate:cifs_revalidate, */
556         .setattr = cifs_setattr,
557         .getattr = cifs_getattr, /* do we need this anymore? */
558         .rename = cifs_rename,
559         .permission = cifs_permission,
560 #ifdef CONFIG_CIFS_XATTR
561         .setxattr = cifs_setxattr,
562         .getxattr = cifs_getxattr,
563         .listxattr = cifs_listxattr,
564         .removexattr = cifs_removexattr,
565 #endif 
566 };
567
568 struct inode_operations cifs_symlink_inode_ops = {
569         .readlink = generic_readlink, 
570         .follow_link = cifs_follow_link,
571         .put_link = cifs_put_link,
572         .permission = cifs_permission,
573         /* BB add the following two eventually */
574         /* revalidate: cifs_revalidate,
575            setattr:    cifs_notify_change, *//* BB do we need notify change */
576 #ifdef CONFIG_CIFS_XATTR
577         .setxattr = cifs_setxattr,
578         .getxattr = cifs_getxattr,
579         .listxattr = cifs_listxattr,
580         .removexattr = cifs_removexattr,
581 #endif 
582 };
583
584 const struct file_operations cifs_file_ops = {
585         .read = do_sync_read,
586         .write = do_sync_write,
587         .readv = generic_file_readv,
588         .writev = cifs_file_writev,
589         .aio_read = generic_file_aio_read,
590         .aio_write = cifs_file_aio_write,
591         .open = cifs_open,
592         .release = cifs_close,
593         .lock = cifs_lock,
594         .fsync = cifs_fsync,
595         .flush = cifs_flush,
596         .mmap  = cifs_file_mmap,
597         .sendfile = generic_file_sendfile,
598         .llseek = cifs_llseek,
599 #ifdef CONFIG_CIFS_POSIX
600         .ioctl  = cifs_ioctl,
601 #endif /* CONFIG_CIFS_POSIX */
602
603 #ifdef CONFIG_CIFS_EXPERIMENTAL
604         .dir_notify = cifs_dir_notify,
605 #endif /* CONFIG_CIFS_EXPERIMENTAL */
606 };
607
608 const struct file_operations cifs_file_direct_ops = {
609         /* no mmap, no aio, no readv - 
610            BB reevaluate whether they can be done with directio, no cache */
611         .read = cifs_user_read,
612         .write = cifs_user_write,
613         .open = cifs_open,
614         .release = cifs_close,
615         .lock = cifs_lock,
616         .fsync = cifs_fsync,
617         .flush = cifs_flush,
618         .sendfile = generic_file_sendfile, /* BB removeme BB */
619 #ifdef CONFIG_CIFS_POSIX
620         .ioctl  = cifs_ioctl,
621 #endif /* CONFIG_CIFS_POSIX */
622         .llseek = cifs_llseek,
623 #ifdef CONFIG_CIFS_EXPERIMENTAL
624         .dir_notify = cifs_dir_notify,
625 #endif /* CONFIG_CIFS_EXPERIMENTAL */
626 };
627 const struct file_operations cifs_file_nobrl_ops = {
628         .read = do_sync_read,
629         .write = do_sync_write,
630         .readv = generic_file_readv,
631         .writev = cifs_file_writev,
632         .aio_read = generic_file_aio_read,
633         .aio_write = cifs_file_aio_write,
634         .open = cifs_open,
635         .release = cifs_close,
636         .fsync = cifs_fsync,
637         .flush = cifs_flush,
638         .mmap  = cifs_file_mmap,
639         .sendfile = generic_file_sendfile,
640         .llseek = cifs_llseek,
641 #ifdef CONFIG_CIFS_POSIX
642         .ioctl  = cifs_ioctl,
643 #endif /* CONFIG_CIFS_POSIX */
644
645 #ifdef CONFIG_CIFS_EXPERIMENTAL
646         .dir_notify = cifs_dir_notify,
647 #endif /* CONFIG_CIFS_EXPERIMENTAL */
648 };
649
650 const struct file_operations cifs_file_direct_nobrl_ops = {
651         /* no mmap, no aio, no readv - 
652            BB reevaluate whether they can be done with directio, no cache */
653         .read = cifs_user_read,
654         .write = cifs_user_write,
655         .open = cifs_open,
656         .release = cifs_close,
657         .fsync = cifs_fsync,
658         .flush = cifs_flush,
659         .sendfile = generic_file_sendfile, /* BB removeme BB */
660 #ifdef CONFIG_CIFS_POSIX
661         .ioctl  = cifs_ioctl,
662 #endif /* CONFIG_CIFS_POSIX */
663         .llseek = cifs_llseek,
664 #ifdef CONFIG_CIFS_EXPERIMENTAL
665         .dir_notify = cifs_dir_notify,
666 #endif /* CONFIG_CIFS_EXPERIMENTAL */
667 };
668
669 const struct file_operations cifs_dir_ops = {
670         .readdir = cifs_readdir,
671         .release = cifs_closedir,
672         .read    = generic_read_dir,
673 #ifdef CONFIG_CIFS_EXPERIMENTAL
674         .dir_notify = cifs_dir_notify,
675 #endif /* CONFIG_CIFS_EXPERIMENTAL */
676         .ioctl  = cifs_ioctl,
677 };
678
679 static void
680 cifs_init_once(void *inode, kmem_cache_t * cachep, unsigned long flags)
681 {
682         struct cifsInodeInfo *cifsi = inode;
683
684         if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
685             SLAB_CTOR_CONSTRUCTOR) {
686                 inode_init_once(&cifsi->vfs_inode);
687                 INIT_LIST_HEAD(&cifsi->lockList);
688         }
689 }
690
691 static int
692 cifs_init_inodecache(void)
693 {
694         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
695                                               sizeof (struct cifsInodeInfo),
696                                               0, (SLAB_RECLAIM_ACCOUNT|
697                                                 SLAB_MEM_SPREAD),
698                                               cifs_init_once, NULL);
699         if (cifs_inode_cachep == NULL)
700                 return -ENOMEM;
701
702         return 0;
703 }
704
705 static void
706 cifs_destroy_inodecache(void)
707 {
708         if (kmem_cache_destroy(cifs_inode_cachep))
709                 printk(KERN_WARNING "cifs_inode_cache: error freeing\n");
710 }
711
712 static int
713 cifs_init_request_bufs(void)
714 {
715         if(CIFSMaxBufSize < 8192) {
716         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
717         Unicode path name has to fit in any SMB/CIFS path based frames */
718                 CIFSMaxBufSize = 8192;
719         } else if (CIFSMaxBufSize > 1024*127) {
720                 CIFSMaxBufSize = 1024 * 127;
721         } else {
722                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
723         }
724 /*      cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
725         cifs_req_cachep = kmem_cache_create("cifs_request",
726                                             CIFSMaxBufSize +
727                                             MAX_CIFS_HDR_SIZE, 0,
728                                             SLAB_HWCACHE_ALIGN, NULL, NULL);
729         if (cifs_req_cachep == NULL)
730                 return -ENOMEM;
731
732         if(cifs_min_rcv < 1)
733                 cifs_min_rcv = 1;
734         else if (cifs_min_rcv > 64) {
735                 cifs_min_rcv = 64;
736                 cERROR(1,("cifs_min_rcv set to maximum (64)"));
737         }
738
739         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
740                                                   cifs_req_cachep);
741
742         if(cifs_req_poolp == NULL) {
743                 kmem_cache_destroy(cifs_req_cachep);
744                 return -ENOMEM;
745         }
746         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
747         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",
755                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN, 
756                         NULL, NULL);
757         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_slab_pool(cifs_min_small,
771                                                      cifs_sm_req_cachep);
772
773         if(cifs_sm_req_poolp == NULL) {
774                 mempool_destroy(cifs_req_poolp);
775                 kmem_cache_destroy(cifs_req_cachep);
776                 kmem_cache_destroy(cifs_sm_req_cachep);
777                 return -ENOMEM;
778         }
779
780         return 0;
781 }
782
783 static void
784 cifs_destroy_request_bufs(void)
785 {
786         mempool_destroy(cifs_req_poolp);
787         if (kmem_cache_destroy(cifs_req_cachep))
788                 printk(KERN_WARNING
789                        "cifs_destroy_request_cache: error not all structures were freed\n");
790         mempool_destroy(cifs_sm_req_poolp);
791         if (kmem_cache_destroy(cifs_sm_req_cachep))
792                 printk(KERN_WARNING
793                       "cifs_destroy_request_cache: cifs_small_rq free error\n");
794 }
795
796 static int
797 cifs_init_mids(void)
798 {
799         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
800                                 sizeof (struct mid_q_entry), 0,
801                                 SLAB_HWCACHE_ALIGN, NULL, NULL);
802         if (cifs_mid_cachep == NULL)
803                 return -ENOMEM;
804
805         /* 3 is a reasonable minimum number of simultaneous operations */
806         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
807         if(cifs_mid_poolp == NULL) {
808                 kmem_cache_destroy(cifs_mid_cachep);
809                 return -ENOMEM;
810         }
811
812         cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
813                                 sizeof (struct oplock_q_entry), 0,
814                                 SLAB_HWCACHE_ALIGN, NULL, NULL);
815         if (cifs_oplock_cachep == NULL) {
816                 kmem_cache_destroy(cifs_mid_cachep);
817                 mempool_destroy(cifs_mid_poolp);
818                 return -ENOMEM;
819         }
820
821         return 0;
822 }
823
824 static void
825 cifs_destroy_mids(void)
826 {
827         mempool_destroy(cifs_mid_poolp);
828         if (kmem_cache_destroy(cifs_mid_cachep))
829                 printk(KERN_WARNING
830                        "cifs_destroy_mids: error not all structures were freed\n");
831
832         if (kmem_cache_destroy(cifs_oplock_cachep))
833                 printk(KERN_WARNING
834                        "error not all oplock structures were freed\n");
835 }
836
837 static int cifs_oplock_thread(void * dummyarg)
838 {
839         struct oplock_q_entry * oplock_item;
840         struct cifsTconInfo *pTcon;
841         struct inode * inode;
842         __u16  netfid;
843         int rc;
844
845         do {
846                 if (try_to_freeze()) 
847                         continue;
848                 
849                 spin_lock(&GlobalMid_Lock);
850                 if(list_empty(&GlobalOplock_Q)) {
851                         spin_unlock(&GlobalMid_Lock);
852                         set_current_state(TASK_INTERRUPTIBLE);
853                         schedule_timeout(39*HZ);
854                 } else {
855                         oplock_item = list_entry(GlobalOplock_Q.next, 
856                                 struct oplock_q_entry, qhead);
857                         if(oplock_item) {
858                                 cFYI(1,("found oplock item to write out")); 
859                                 pTcon = oplock_item->tcon;
860                                 inode = oplock_item->pinode;
861                                 netfid = oplock_item->netfid;
862                                 spin_unlock(&GlobalMid_Lock);
863                                 DeleteOplockQEntry(oplock_item);
864                                 /* can not grab inode sem here since it would
865                                 deadlock when oplock received on delete 
866                                 since vfs_unlink holds the i_mutex across
867                                 the call */
868                                 /* mutex_lock(&inode->i_mutex);*/
869                                 if (S_ISREG(inode->i_mode)) {
870                                         rc = filemap_fdatawrite(inode->i_mapping);
871                                         if(CIFS_I(inode)->clientCanCacheRead == 0) {
872                                                 filemap_fdatawait(inode->i_mapping);
873                                                 invalidate_remote_inode(inode);
874                                         }
875                                 } else
876                                         rc = 0;
877                                 /* mutex_unlock(&inode->i_mutex);*/
878                                 if (rc)
879                                         CIFS_I(inode)->write_behind_rc = rc;
880                                 cFYI(1,("Oplock flush inode %p rc %d",inode,rc));
881
882                                 /* releasing a stale oplock after recent reconnection 
883                                 of smb session using a now incorrect file 
884                                 handle is not a data integrity issue but do  
885                                 not bother sending an oplock release if session 
886                                 to server still is disconnected since oplock 
887                                 already released by the server in that case */
888                                 if(pTcon->tidStatus != CifsNeedReconnect) {
889                                     rc = CIFSSMBLock(0, pTcon, netfid,
890                                             0 /* len */ , 0 /* offset */, 0, 
891                                             0, LOCKING_ANDX_OPLOCK_RELEASE,
892                                             0 /* wait flag */);
893                                         cFYI(1,("Oplock release rc = %d ",rc));
894                                 }
895                         } else
896                                 spin_unlock(&GlobalMid_Lock);
897                         set_current_state(TASK_INTERRUPTIBLE);
898                         schedule_timeout(1);  /* yield in case q were corrupt */
899                 }
900         } while (!kthread_should_stop());
901
902         return 0;
903 }
904
905 static int cifs_dnotify_thread(void * dummyarg)
906 {
907         struct list_head *tmp;
908         struct cifsSesInfo *ses;
909
910         do {
911                 if (try_to_freeze())
912                         continue;
913                 set_current_state(TASK_INTERRUPTIBLE);
914                 schedule_timeout(15*HZ);
915                 read_lock(&GlobalSMBSeslock);
916                 /* check if any stuck requests that need
917                    to be woken up and wakeq so the
918                    thread can wake up and error out */
919                 list_for_each(tmp, &GlobalSMBSessionList) {
920                         ses = list_entry(tmp, struct cifsSesInfo, 
921                                 cifsSessionList);
922                         if(ses && ses->server && 
923                              atomic_read(&ses->server->inFlight))
924                                 wake_up_all(&ses->server->response_q);
925                 }
926                 read_unlock(&GlobalSMBSeslock);
927         } while (!kthread_should_stop());
928
929         return 0;
930 }
931
932 static int __init
933 init_cifs(void)
934 {
935         int rc = 0;
936 #ifdef CONFIG_PROC_FS
937         cifs_proc_init();
938 #endif
939         INIT_LIST_HEAD(&GlobalServerList);      /* BB not implemented yet */
940         INIT_LIST_HEAD(&GlobalSMBSessionList);
941         INIT_LIST_HEAD(&GlobalTreeConnectionList);
942         INIT_LIST_HEAD(&GlobalOplock_Q);
943 #ifdef CONFIG_CIFS_EXPERIMENTAL
944         INIT_LIST_HEAD(&GlobalDnotifyReqList);
945         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
946 #endif  
947 /*
948  *  Initialize Global counters
949  */
950         atomic_set(&sesInfoAllocCount, 0);
951         atomic_set(&tconInfoAllocCount, 0);
952         atomic_set(&tcpSesAllocCount,0);
953         atomic_set(&tcpSesReconnectCount, 0);
954         atomic_set(&tconInfoReconnectCount, 0);
955
956         atomic_set(&bufAllocCount, 0);
957         atomic_set(&smBufAllocCount, 0);
958 #ifdef CONFIG_CIFS_STATS2
959         atomic_set(&totBufAllocCount, 0);
960         atomic_set(&totSmBufAllocCount, 0);
961 #endif /* CONFIG_CIFS_STATS2 */
962
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                 goto out_clean_proc;
981
982         rc = cifs_init_mids();
983         if (rc)
984                 goto out_destroy_inodecache;
985
986         rc = cifs_init_request_bufs();
987         if (rc)
988                 goto out_destroy_mids;
989
990         rc = register_filesystem(&cifs_fs_type);
991         if (rc)
992                 goto out_destroy_request_bufs;
993
994         oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
995         if (IS_ERR(oplockThread)) {
996                 rc = PTR_ERR(oplockThread);
997                 cERROR(1,("error %d create oplock thread", rc));
998                 goto out_unregister_filesystem;
999         }
1000
1001         dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
1002         if (IS_ERR(dnotifyThread)) {
1003                 rc = PTR_ERR(dnotifyThread);
1004                 cERROR(1,("error %d create dnotify thread", rc));
1005                 goto out_stop_oplock_thread;
1006         }
1007
1008         return 0;
1009
1010  out_stop_oplock_thread:
1011         kthread_stop(oplockThread);
1012  out_unregister_filesystem:
1013         unregister_filesystem(&cifs_fs_type);
1014  out_destroy_request_bufs:
1015         cifs_destroy_request_bufs();
1016  out_destroy_mids:
1017         cifs_destroy_mids();
1018  out_destroy_inodecache:
1019         cifs_destroy_inodecache();
1020  out_clean_proc:
1021 #ifdef CONFIG_PROC_FS
1022         cifs_proc_clean();
1023 #endif
1024         return rc;
1025 }
1026
1027 static void __exit
1028 exit_cifs(void)
1029 {
1030         cFYI(0, ("In unregister ie exit_cifs"));
1031 #ifdef CONFIG_PROC_FS
1032         cifs_proc_clean();
1033 #endif
1034         unregister_filesystem(&cifs_fs_type);
1035         cifs_destroy_inodecache();
1036         cifs_destroy_mids();
1037         cifs_destroy_request_bufs();
1038         kthread_stop(oplockThread);
1039         kthread_stop(dnotifyThread);
1040 }
1041
1042 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1043 MODULE_LICENSE("GPL");          /* combination of LGPL + GPL source behaves as GPL */
1044 MODULE_DESCRIPTION
1045     ("VFS to access servers complying with the SNIA CIFS Specification e.g. Samba and Windows");
1046 MODULE_VERSION(CIFS_VERSION);
1047 module_init(init_cifs)
1048 module_exit(exit_cifs)