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