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