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