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