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