]> bbs.cooldavid.org Git - net-next-2.6.git/blame_incremental - fs/cifs/cifsfs.c
git://bbs.cooldavid.org / net-next-2.6.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
[CIFS] Fix hang in mount when negprot causes server to kill tcp session
[net-next-2.6.git] / fs / cifs / cifsfs.c
... / ...
CommitLineData
1/*
2 * fs/cifs/cifsfs.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2008
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
52static struct quotactl_ops cifs_quotactl_ops;
53#endif /* QUOTA */
54
55int cifsFYI = 0;
56int cifsERROR = 1;
57int traceSMB = 0;
58unsigned int oplockEnabled = 1;
59unsigned int experimEnabled = 0;
60unsigned int linuxExtEnabled = 1;
61unsigned int lookupCacheEnabled = 1;
62unsigned int multiuser_mount = 0;
63unsigned int extended_security = CIFSSEC_DEF;
64/* unsigned int ntlmv2_support = 0; */
65unsigned int sign_CIFS_PDUs = 1;
66extern struct task_struct *oplockThread; /* remove sparse warning */
67struct task_struct *oplockThread = NULL;
68/* extern struct task_struct * dnotifyThread; remove sparse warning */
69static struct task_struct *dnotifyThread = NULL;
70static const struct super_operations cifs_super_ops;
71unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
72module_param(CIFSMaxBufSize, int, 0);
73MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
74 "Default: 16384 Range: 8192 to 130048");
75unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
76module_param(cifs_min_rcv, int, 0);
77MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
78 "1 to 64");
79unsigned int cifs_min_small = 30;
80module_param(cifs_min_small, int, 0);
81MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
82 "Range: 2 to 256");
83unsigned int cifs_max_pending = CIFS_MAX_REQ;
84module_param(cifs_max_pending, int, 0);
85MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
86 "Default: 50 Range: 2 to 256");
87
88extern mempool_t *cifs_sm_req_poolp;
89extern mempool_t *cifs_req_poolp;
90extern mempool_t *cifs_mid_poolp;
91
92extern struct kmem_cache *cifs_oplock_cachep;
93
94static int
95cifs_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
174out_no_root:
175 cERROR(1, ("cifs_read_super: get root inode failed"));
176 if (inode)
177 iput(inode);
178
179out_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
194static void
195cifs_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
221static int
222cifs_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
271static 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
286static struct kmem_cache *cifs_inode_cachep;
287static struct kmem_cache *cifs_req_cachep;
288static struct kmem_cache *cifs_mid_cachep;
289struct kmem_cache *cifs_oplock_cachep;
290static struct kmem_cache *cifs_sm_req_cachep;
291mempool_t *cifs_sm_req_poolp;
292mempool_t *cifs_req_poolp;
293mempool_t *cifs_mid_poolp;
294
295static struct inode *
296cifs_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
320static void
321cifs_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 */
331static int
332cifs_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 if (!cifs_sb->tcon->unix_ext) {
357 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
358 cifs_sb->mnt_file_mode,
359 cifs_sb->mnt_dir_mode);
360 }
361 if (cifs_sb->tcon->seal)
362 seq_printf(s, ",seal");
363 if (cifs_sb->tcon->nocase)
364 seq_printf(s, ",nocase");
365 if (cifs_sb->tcon->retry)
366 seq_printf(s, ",hard");
367 }
368 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
369 seq_printf(s, ",posixpaths");
370 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
371 seq_printf(s, ",setuids");
372 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
373 seq_printf(s, ",serverino");
374 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
375 seq_printf(s, ",directio");
376 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
377 seq_printf(s, ",nouser_xattr");
378 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
379 seq_printf(s, ",mapchars");
380 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
381 seq_printf(s, ",sfu");
382 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
383 seq_printf(s, ",nobrl");
384 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
385 seq_printf(s, ",cifsacl");
386 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
387 seq_printf(s, ",dynperm");
388 if (m->mnt_sb->s_flags & MS_POSIXACL)
389 seq_printf(s, ",acl");
390
391 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
392 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
393 }
394 return 0;
395}
396
397#ifdef CONFIG_CIFS_QUOTA
398int cifs_xquota_set(struct super_block *sb, int quota_type, qid_t qid,
399 struct fs_disk_quota *pdquota)
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
412 xid = GetXid();
413 if (pTcon) {
414 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
415 } else {
416 rc = -EIO;
417 }
418
419 FreeXid(xid);
420 return rc;
421}
422
423int cifs_xquota_get(struct super_block *sb, int quota_type, qid_t qid,
424 struct fs_disk_quota *pdquota)
425{
426 int xid;
427 int rc = 0;
428 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
429 struct cifsTconInfo *pTcon;
430
431 if (cifs_sb)
432 pTcon = cifs_sb->tcon;
433 else
434 return -EIO;
435
436 xid = GetXid();
437 if (pTcon) {
438 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
439 } else {
440 rc = -EIO;
441 }
442
443 FreeXid(xid);
444 return rc;
445}
446
447int cifs_xstate_set(struct super_block *sb, unsigned int flags, int operation)
448{
449 int xid;
450 int rc = 0;
451 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
452 struct cifsTconInfo *pTcon;
453
454 if (cifs_sb)
455 pTcon = cifs_sb->tcon;
456 else
457 return -EIO;
458
459 xid = GetXid();
460 if (pTcon) {
461 cFYI(1, ("flags: 0x%x operation: 0x%x", flags, operation));
462 } else {
463 rc = -EIO;
464 }
465
466 FreeXid(xid);
467 return rc;
468}
469
470int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
471{
472 int xid;
473 int rc = 0;
474 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
475 struct cifsTconInfo *pTcon;
476
477 if (cifs_sb) {
478 pTcon = cifs_sb->tcon;
479 } else {
480 return -EIO;
481 }
482 xid = GetXid();
483 if (pTcon) {
484 cFYI(1, ("pqstats %p", qstats));
485 } else {
486 rc = -EIO;
487 }
488
489 FreeXid(xid);
490 return rc;
491}
492
493static struct quotactl_ops cifs_quotactl_ops = {
494 .set_xquota = cifs_xquota_set,
495 .get_xquota = cifs_xquota_get,
496 .set_xstate = cifs_xstate_set,
497 .get_xstate = cifs_xstate_get,
498};
499#endif
500
501static void cifs_umount_begin(struct super_block *sb)
502{
503 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
504 struct cifsTconInfo *tcon;
505
506 if (cifs_sb == NULL)
507 return;
508
509 tcon = cifs_sb->tcon;
510 if (tcon == NULL)
511 return;
512 down(&tcon->tconSem);
513 if (atomic_read(&tcon->useCount) == 1)
514 tcon->tidStatus = CifsExiting;
515 up(&tcon->tconSem);
516
517 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
518 /* cancel_notify_requests(tcon); */
519 if (tcon->ses && tcon->ses->server) {
520 cFYI(1, ("wake up tasks now - umount begin not complete"));
521 wake_up_all(&tcon->ses->server->request_q);
522 wake_up_all(&tcon->ses->server->response_q);
523 msleep(1); /* yield */
524 /* we have to kick the requests once more */
525 wake_up_all(&tcon->ses->server->response_q);
526 msleep(1);
527 }
528/* BB FIXME - finish add checks for tidStatus BB */
529
530 return;
531}
532
533#ifdef CONFIG_CIFS_STATS2
534static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
535{
536 /* BB FIXME */
537 return 0;
538}
539#endif
540
541static int cifs_remount(struct super_block *sb, int *flags, char *data)
542{
543 *flags |= MS_NODIRATIME;
544 return 0;
545}
546
547static const struct super_operations cifs_super_ops = {
548 .put_super = cifs_put_super,
549 .statfs = cifs_statfs,
550 .alloc_inode = cifs_alloc_inode,
551 .destroy_inode = cifs_destroy_inode,
552/* .drop_inode = generic_delete_inode,
553 .delete_inode = cifs_delete_inode, */ /* Do not need above two
554 functions unless later we add lazy close of inodes or unless the
555 kernel forgets to call us with the same number of releases (closes)
556 as opens */
557 .show_options = cifs_show_options,
558 .umount_begin = cifs_umount_begin,
559 .remount_fs = cifs_remount,
560#ifdef CONFIG_CIFS_STATS2
561 .show_stats = cifs_show_stats,
562#endif
563};
564
565static int
566cifs_get_sb(struct file_system_type *fs_type,
567 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
568{
569 int rc;
570 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
571
572 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
573
574 if (IS_ERR(sb))
575 return PTR_ERR(sb);
576
577 sb->s_flags = flags;
578
579 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
580 if (rc) {
581 up_write(&sb->s_umount);
582 deactivate_super(sb);
583 return rc;
584 }
585 sb->s_flags |= MS_ACTIVE;
586 return simple_set_mnt(mnt, sb);
587}
588
589static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
590 unsigned long nr_segs, loff_t pos)
591{
592 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
593 ssize_t written;
594
595 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
596 if (!CIFS_I(inode)->clientCanCacheAll)
597 filemap_fdatawrite(inode->i_mapping);
598 return written;
599}
600
601static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
602{
603 /* origin == SEEK_END => we must revalidate the cached file length */
604 if (origin == SEEK_END) {
605 int retval;
606
607 /* some applications poll for the file length in this strange
608 way so we must seek to end on non-oplocked files by
609 setting the revalidate time to zero */
610 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
611
612 retval = cifs_revalidate(file->f_path.dentry);
613 if (retval < 0)
614 return (loff_t)retval;
615 }
616 return remote_llseek(file, offset, origin);
617}
618
619struct file_system_type cifs_fs_type = {
620 .owner = THIS_MODULE,
621 .name = "cifs",
622 .get_sb = cifs_get_sb,
623 .kill_sb = kill_anon_super,
624 /* .fs_flags */
625};
626const struct inode_operations cifs_dir_inode_ops = {
627 .create = cifs_create,
628 .lookup = cifs_lookup,
629 .getattr = cifs_getattr,
630 .unlink = cifs_unlink,
631 .link = cifs_hardlink,
632 .mkdir = cifs_mkdir,
633 .rmdir = cifs_rmdir,
634 .rename = cifs_rename,
635 .permission = cifs_permission,
636/* revalidate:cifs_revalidate, */
637 .setattr = cifs_setattr,
638 .symlink = cifs_symlink,
639 .mknod = cifs_mknod,
640#ifdef CONFIG_CIFS_XATTR
641 .setxattr = cifs_setxattr,
642 .getxattr = cifs_getxattr,
643 .listxattr = cifs_listxattr,
644 .removexattr = cifs_removexattr,
645#endif
646};
647
648const struct inode_operations cifs_file_inode_ops = {
649/* revalidate:cifs_revalidate, */
650 .setattr = cifs_setattr,
651 .getattr = cifs_getattr, /* do we need this anymore? */
652 .rename = cifs_rename,
653 .permission = cifs_permission,
654#ifdef CONFIG_CIFS_XATTR
655 .setxattr = cifs_setxattr,
656 .getxattr = cifs_getxattr,
657 .listxattr = cifs_listxattr,
658 .removexattr = cifs_removexattr,
659#endif
660};
661
662const struct inode_operations cifs_symlink_inode_ops = {
663 .readlink = generic_readlink,
664 .follow_link = cifs_follow_link,
665 .put_link = cifs_put_link,
666 .permission = cifs_permission,
667 /* BB add the following two eventually */
668 /* revalidate: cifs_revalidate,
669 setattr: cifs_notify_change, *//* BB do we need notify change */
670#ifdef CONFIG_CIFS_XATTR
671 .setxattr = cifs_setxattr,
672 .getxattr = cifs_getxattr,
673 .listxattr = cifs_listxattr,
674 .removexattr = cifs_removexattr,
675#endif
676};
677
678const struct file_operations cifs_file_ops = {
679 .read = do_sync_read,
680 .write = do_sync_write,
681 .aio_read = generic_file_aio_read,
682 .aio_write = cifs_file_aio_write,
683 .open = cifs_open,
684 .release = cifs_close,
685 .lock = cifs_lock,
686 .fsync = cifs_fsync,
687 .flush = cifs_flush,
688 .mmap = cifs_file_mmap,
689 .splice_read = generic_file_splice_read,
690 .llseek = cifs_llseek,
691#ifdef CONFIG_CIFS_POSIX
692 .unlocked_ioctl = cifs_ioctl,
693#endif /* CONFIG_CIFS_POSIX */
694
695#ifdef CONFIG_CIFS_EXPERIMENTAL
696 .dir_notify = cifs_dir_notify,
697#endif /* CONFIG_CIFS_EXPERIMENTAL */
698};
699
700const struct file_operations cifs_file_direct_ops = {
701 /* no mmap, no aio, no readv -
702 BB reevaluate whether they can be done with directio, no cache */
703 .read = cifs_user_read,
704 .write = cifs_user_write,
705 .open = cifs_open,
706 .release = cifs_close,
707 .lock = cifs_lock,
708 .fsync = cifs_fsync,
709 .flush = cifs_flush,
710 .splice_read = generic_file_splice_read,
711#ifdef CONFIG_CIFS_POSIX
712 .unlocked_ioctl = cifs_ioctl,
713#endif /* CONFIG_CIFS_POSIX */
714 .llseek = cifs_llseek,
715#ifdef CONFIG_CIFS_EXPERIMENTAL
716 .dir_notify = cifs_dir_notify,
717#endif /* CONFIG_CIFS_EXPERIMENTAL */
718};
719const struct file_operations cifs_file_nobrl_ops = {
720 .read = do_sync_read,
721 .write = do_sync_write,
722 .aio_read = generic_file_aio_read,
723 .aio_write = cifs_file_aio_write,
724 .open = cifs_open,
725 .release = cifs_close,
726 .fsync = cifs_fsync,
727 .flush = cifs_flush,
728 .mmap = cifs_file_mmap,
729 .splice_read = generic_file_splice_read,
730 .llseek = cifs_llseek,
731#ifdef CONFIG_CIFS_POSIX
732 .unlocked_ioctl = cifs_ioctl,
733#endif /* CONFIG_CIFS_POSIX */
734
735#ifdef CONFIG_CIFS_EXPERIMENTAL
736 .dir_notify = cifs_dir_notify,
737#endif /* CONFIG_CIFS_EXPERIMENTAL */
738};
739
740const struct file_operations cifs_file_direct_nobrl_ops = {
741 /* no mmap, no aio, no readv -
742 BB reevaluate whether they can be done with directio, no cache */
743 .read = cifs_user_read,
744 .write = cifs_user_write,
745 .open = cifs_open,
746 .release = cifs_close,
747 .fsync = cifs_fsync,
748 .flush = cifs_flush,
749 .splice_read = generic_file_splice_read,
750#ifdef CONFIG_CIFS_POSIX
751 .unlocked_ioctl = cifs_ioctl,
752#endif /* CONFIG_CIFS_POSIX */
753 .llseek = cifs_llseek,
754#ifdef CONFIG_CIFS_EXPERIMENTAL
755 .dir_notify = cifs_dir_notify,
756#endif /* CONFIG_CIFS_EXPERIMENTAL */
757};
758
759const struct file_operations cifs_dir_ops = {
760 .readdir = cifs_readdir,
761 .release = cifs_closedir,
762 .read = generic_read_dir,
763#ifdef CONFIG_CIFS_EXPERIMENTAL
764 .dir_notify = cifs_dir_notify,
765#endif /* CONFIG_CIFS_EXPERIMENTAL */
766 .unlocked_ioctl = cifs_ioctl,
767};
768
769static void
770cifs_init_once(struct kmem_cache *cachep, void *inode)
771{
772 struct cifsInodeInfo *cifsi = inode;
773
774 inode_init_once(&cifsi->vfs_inode);
775 INIT_LIST_HEAD(&cifsi->lockList);
776}
777
778static int
779cifs_init_inodecache(void)
780{
781 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
782 sizeof(struct cifsInodeInfo),
783 0, (SLAB_RECLAIM_ACCOUNT|
784 SLAB_MEM_SPREAD),
785 cifs_init_once);
786 if (cifs_inode_cachep == NULL)
787 return -ENOMEM;
788
789 return 0;
790}
791
792static void
793cifs_destroy_inodecache(void)
794{
795 kmem_cache_destroy(cifs_inode_cachep);
796}
797
798static int
799cifs_init_request_bufs(void)
800{
801 if (CIFSMaxBufSize < 8192) {
802 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
803 Unicode path name has to fit in any SMB/CIFS path based frames */
804 CIFSMaxBufSize = 8192;
805 } else if (CIFSMaxBufSize > 1024*127) {
806 CIFSMaxBufSize = 1024 * 127;
807 } else {
808 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
809 }
810/* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
811 cifs_req_cachep = kmem_cache_create("cifs_request",
812 CIFSMaxBufSize +
813 MAX_CIFS_HDR_SIZE, 0,
814 SLAB_HWCACHE_ALIGN, NULL);
815 if (cifs_req_cachep == NULL)
816 return -ENOMEM;
817
818 if (cifs_min_rcv < 1)
819 cifs_min_rcv = 1;
820 else if (cifs_min_rcv > 64) {
821 cifs_min_rcv = 64;
822 cERROR(1, ("cifs_min_rcv set to maximum (64)"));
823 }
824
825 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
826 cifs_req_cachep);
827
828 if (cifs_req_poolp == NULL) {
829 kmem_cache_destroy(cifs_req_cachep);
830 return -ENOMEM;
831 }
832 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
833 almost all handle based requests (but not write response, nor is it
834 sufficient for path based requests). A smaller size would have
835 been more efficient (compacting multiple slab items on one 4k page)
836 for the case in which debug was on, but this larger size allows
837 more SMBs to use small buffer alloc and is still much more
838 efficient to alloc 1 per page off the slab compared to 17K (5page)
839 alloc of large cifs buffers even when page debugging is on */
840 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
841 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
842 NULL);
843 if (cifs_sm_req_cachep == NULL) {
844 mempool_destroy(cifs_req_poolp);
845 kmem_cache_destroy(cifs_req_cachep);
846 return -ENOMEM;
847 }
848
849 if (cifs_min_small < 2)
850 cifs_min_small = 2;
851 else if (cifs_min_small > 256) {
852 cifs_min_small = 256;
853 cFYI(1, ("cifs_min_small set to maximum (256)"));
854 }
855
856 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
857 cifs_sm_req_cachep);
858
859 if (cifs_sm_req_poolp == NULL) {
860 mempool_destroy(cifs_req_poolp);
861 kmem_cache_destroy(cifs_req_cachep);
862 kmem_cache_destroy(cifs_sm_req_cachep);
863 return -ENOMEM;
864 }
865
866 return 0;
867}
868
869static void
870cifs_destroy_request_bufs(void)
871{
872 mempool_destroy(cifs_req_poolp);
873 kmem_cache_destroy(cifs_req_cachep);
874 mempool_destroy(cifs_sm_req_poolp);
875 kmem_cache_destroy(cifs_sm_req_cachep);
876}
877
878static int
879cifs_init_mids(void)
880{
881 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
882 sizeof(struct mid_q_entry), 0,
883 SLAB_HWCACHE_ALIGN, NULL);
884 if (cifs_mid_cachep == NULL)
885 return -ENOMEM;
886
887 /* 3 is a reasonable minimum number of simultaneous operations */
888 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
889 if (cifs_mid_poolp == NULL) {
890 kmem_cache_destroy(cifs_mid_cachep);
891 return -ENOMEM;
892 }
893
894 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
895 sizeof(struct oplock_q_entry), 0,
896 SLAB_HWCACHE_ALIGN, NULL);
897 if (cifs_oplock_cachep == NULL) {
898 mempool_destroy(cifs_mid_poolp);
899 kmem_cache_destroy(cifs_mid_cachep);
900 return -ENOMEM;
901 }
902
903 return 0;
904}
905
906static void
907cifs_destroy_mids(void)
908{
909 mempool_destroy(cifs_mid_poolp);
910 kmem_cache_destroy(cifs_mid_cachep);
911 kmem_cache_destroy(cifs_oplock_cachep);
912}
913
914static int cifs_oplock_thread(void *dummyarg)
915{
916 struct oplock_q_entry *oplock_item;
917 struct cifsTconInfo *pTcon;
918 struct inode *inode;
919 __u16 netfid;
920 int rc, waitrc = 0;
921
922 set_freezable();
923 do {
924 if (try_to_freeze())
925 continue;
926
927 spin_lock(&GlobalMid_Lock);
928 if (list_empty(&GlobalOplock_Q)) {
929 spin_unlock(&GlobalMid_Lock);
930 set_current_state(TASK_INTERRUPTIBLE);
931 schedule_timeout(39*HZ);
932 } else {
933 oplock_item = list_entry(GlobalOplock_Q.next,
934 struct oplock_q_entry, qhead);
935 if (oplock_item) {
936 cFYI(1, ("found oplock item to write out"));
937 pTcon = oplock_item->tcon;
938 inode = oplock_item->pinode;
939 netfid = oplock_item->netfid;
940 spin_unlock(&GlobalMid_Lock);
941 DeleteOplockQEntry(oplock_item);
942 /* can not grab inode sem here since it would
943 deadlock when oplock received on delete
944 since vfs_unlink holds the i_mutex across
945 the call */
946 /* mutex_lock(&inode->i_mutex);*/
947 if (S_ISREG(inode->i_mode)) {
948 rc =
949 filemap_fdatawrite(inode->i_mapping);
950 if (CIFS_I(inode)->clientCanCacheRead
951 == 0) {
952 waitrc = filemap_fdatawait(inode->i_mapping);
953 invalidate_remote_inode(inode);
954 }
955 if (rc == 0)
956 rc = waitrc;
957 } else
958 rc = 0;
959 /* mutex_unlock(&inode->i_mutex);*/
960 if (rc)
961 CIFS_I(inode)->write_behind_rc = rc;
962 cFYI(1, ("Oplock flush inode %p rc %d",
963 inode, rc));
964
965 /* releasing stale oplock after recent reconnect
966 of smb session using a now incorrect file
967 handle is not a data integrity issue but do
968 not bother sending an oplock release if session
969 to server still is disconnected since oplock
970 already released by the server in that case */
971 if (pTcon->tidStatus != CifsNeedReconnect) {
972 rc = CIFSSMBLock(0, pTcon, netfid,
973 0 /* len */ , 0 /* offset */, 0,
974 0, LOCKING_ANDX_OPLOCK_RELEASE,
975 false /* wait flag */);
976 cFYI(1, ("Oplock release rc = %d", rc));
977 }
978 } else
979 spin_unlock(&GlobalMid_Lock);
980 set_current_state(TASK_INTERRUPTIBLE);
981 schedule_timeout(1); /* yield in case q were corrupt */
982 }
983 } while (!kthread_should_stop());
984
985 return 0;
986}
987
988static int cifs_dnotify_thread(void *dummyarg)
989{
990 struct list_head *tmp;
991 struct cifsSesInfo *ses;
992
993 do {
994 if (try_to_freeze())
995 continue;
996 set_current_state(TASK_INTERRUPTIBLE);
997 schedule_timeout(15*HZ);
998 read_lock(&GlobalSMBSeslock);
999 /* check if any stuck requests that need
1000 to be woken up and wakeq so the
1001 thread can wake up and error out */
1002 list_for_each(tmp, &GlobalSMBSessionList) {
1003 ses = list_entry(tmp, struct cifsSesInfo,
1004 cifsSessionList);
1005 if (ses && ses->server &&
1006 atomic_read(&ses->server->inFlight))
1007 wake_up_all(&ses->server->response_q);
1008 }
1009 read_unlock(&GlobalSMBSeslock);
1010 } while (!kthread_should_stop());
1011
1012 return 0;
1013}
1014
1015static int __init
1016init_cifs(void)
1017{
1018 int rc = 0;
1019 cifs_proc_init();
1020/* INIT_LIST_HEAD(&GlobalServerList);*/ /* BB not implemented yet */
1021 INIT_LIST_HEAD(&GlobalSMBSessionList);
1022 INIT_LIST_HEAD(&GlobalTreeConnectionList);
1023 INIT_LIST_HEAD(&GlobalOplock_Q);
1024#ifdef CONFIG_CIFS_EXPERIMENTAL
1025 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1026 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1027#endif
1028/*
1029 * Initialize Global counters
1030 */
1031 atomic_set(&sesInfoAllocCount, 0);
1032 atomic_set(&tconInfoAllocCount, 0);
1033 atomic_set(&tcpSesAllocCount, 0);
1034 atomic_set(&tcpSesReconnectCount, 0);
1035 atomic_set(&tconInfoReconnectCount, 0);
1036
1037 atomic_set(&bufAllocCount, 0);
1038 atomic_set(&smBufAllocCount, 0);
1039#ifdef CONFIG_CIFS_STATS2
1040 atomic_set(&totBufAllocCount, 0);
1041 atomic_set(&totSmBufAllocCount, 0);
1042#endif /* CONFIG_CIFS_STATS2 */
1043
1044 atomic_set(&midCount, 0);
1045 GlobalCurrentXid = 0;
1046 GlobalTotalActiveXid = 0;
1047 GlobalMaxActiveXid = 0;
1048 memset(Local_System_Name, 0, 15);
1049 rwlock_init(&GlobalSMBSeslock);
1050 spin_lock_init(&GlobalMid_Lock);
1051
1052 if (cifs_max_pending < 2) {
1053 cifs_max_pending = 2;
1054 cFYI(1, ("cifs_max_pending set to min of 2"));
1055 } else if (cifs_max_pending > 256) {
1056 cifs_max_pending = 256;
1057 cFYI(1, ("cifs_max_pending set to max of 256"));
1058 }
1059
1060 rc = cifs_init_inodecache();
1061 if (rc)
1062 goto out_clean_proc;
1063
1064 rc = cifs_init_mids();
1065 if (rc)
1066 goto out_destroy_inodecache;
1067
1068 rc = cifs_init_request_bufs();
1069 if (rc)
1070 goto out_destroy_mids;
1071
1072 rc = register_filesystem(&cifs_fs_type);
1073 if (rc)
1074 goto out_destroy_request_bufs;
1075#ifdef CONFIG_CIFS_UPCALL
1076 rc = register_key_type(&cifs_spnego_key_type);
1077 if (rc)
1078 goto out_unregister_filesystem;
1079#endif
1080#ifdef CONFIG_CIFS_DFS_UPCALL
1081 rc = register_key_type(&key_type_dns_resolver);
1082 if (rc)
1083 goto out_unregister_key_type;
1084#endif
1085 oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
1086 if (IS_ERR(oplockThread)) {
1087 rc = PTR_ERR(oplockThread);
1088 cERROR(1, ("error %d create oplock thread", rc));
1089 goto out_unregister_dfs_key_type;
1090 }
1091
1092 dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
1093 if (IS_ERR(dnotifyThread)) {
1094 rc = PTR_ERR(dnotifyThread);
1095 cERROR(1, ("error %d create dnotify thread", rc));
1096 goto out_stop_oplock_thread;
1097 }
1098
1099 return 0;
1100
1101 out_stop_oplock_thread:
1102 kthread_stop(oplockThread);
1103 out_unregister_dfs_key_type:
1104#ifdef CONFIG_CIFS_DFS_UPCALL
1105 unregister_key_type(&key_type_dns_resolver);
1106 out_unregister_key_type:
1107#endif
1108#ifdef CONFIG_CIFS_UPCALL
1109 unregister_key_type(&cifs_spnego_key_type);
1110 out_unregister_filesystem:
1111#endif
1112 unregister_filesystem(&cifs_fs_type);
1113 out_destroy_request_bufs:
1114 cifs_destroy_request_bufs();
1115 out_destroy_mids:
1116 cifs_destroy_mids();
1117 out_destroy_inodecache:
1118 cifs_destroy_inodecache();
1119 out_clean_proc:
1120 cifs_proc_clean();
1121 return rc;
1122}
1123
1124static void __exit
1125exit_cifs(void)
1126{
1127 cFYI(DBG2, ("exit_cifs"));
1128 cifs_proc_clean();
1129#ifdef CONFIG_CIFS_DFS_UPCALL
1130 cifs_dfs_release_automount_timer();
1131 unregister_key_type(&key_type_dns_resolver);
1132#endif
1133#ifdef CONFIG_CIFS_UPCALL
1134 unregister_key_type(&cifs_spnego_key_type);
1135#endif
1136 unregister_filesystem(&cifs_fs_type);
1137 cifs_destroy_inodecache();
1138 cifs_destroy_mids();
1139 cifs_destroy_request_bufs();
1140 kthread_stop(oplockThread);
1141 kthread_stop(dnotifyThread);
1142}
1143
1144MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1145MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1146MODULE_DESCRIPTION
1147 ("VFS to access servers complying with the SNIA CIFS Specification "
1148 "e.g. Samba and Windows");
1149MODULE_VERSION(CIFS_VERSION);
1150module_init(init_cifs)
1151module_exit(exit_cifs)
Clone of davem's net-next-2.6 tree