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