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