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