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