projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] Vectorize aio_read/aio_write fileop methods
[GitHub/mt8127/android_kernel_alcatel_ttab.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;
3979877e
SF		 59unsigned int extended_security = CIFSSEC_DEF;
60/* unsigned int ntlmv2_support = 0; */
1da177e4
LT		 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
1da177e4 192/* BB we could add a second check for a QFS Unix capability bit */
f28ac91b 193/* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */
c81156dd
SF		 194 if ((pTcon->ses->capabilities & CAP_UNIX) && (CIFS_POSIX_EXTENSIONS &
195 le64_to_cpu(pTcon->fsUnixInfo.Capability)))
737b758c 196 rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf);
1da177e4
LT		 197
198 /* Only need to call the old QFSInfo if failed
199 on newer one */
200 if(rc)
737b758c 201 rc = CIFSSMBQFSInfo(xid, pTcon, buf);
1da177e4 202
20962438
SF		 203 /* Old Windows servers do not support level 103, retry with level
204 one if old server failed the previous call */
205 if(rc)
206 rc = SMBOldQFSInfo(xid, pTcon, buf);
1da177e4
LT		 207 /*
208 int f_type;
209 __fsid_t f_fsid;
210 int f_namelen; */
c81156dd 211 /* BB get from info in tcon struct at mount time call to QFSAttrInfo */
1da177e4 212 FreeXid(xid);
c81156dd
SF		 213 return 0; /* always return success? what if volume is no
214 longer available? */
1da177e4
LT		 215}
216
217static int cifs_permission(struct inode * inode, int mask, struct nameidata *nd)
218{
219 struct cifs_sb_info *cifs_sb;
220
221 cifs_sb = CIFS_SB(inode->i_sb);
222
223 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
224 return 0;
225 } else /* file mode might have been restricted at mount time
226 on the client (above and beyond ACL on servers) for
227 servers which do not support setting and viewing mode bits,
228 so allowing client to check permissions is useful */
229 return generic_permission(inode, mask, NULL);
230}
231
232static kmem_cache_t *cifs_inode_cachep;
233static kmem_cache_t *cifs_req_cachep;
234static kmem_cache_t *cifs_mid_cachep;
235kmem_cache_t *cifs_oplock_cachep;
236static kmem_cache_t *cifs_sm_req_cachep;
237mempool_t *cifs_sm_req_poolp;
238mempool_t *cifs_req_poolp;
239mempool_t *cifs_mid_poolp;
240
241static struct inode *
242cifs_alloc_inode(struct super_block *sb)
243{
244 struct cifsInodeInfo *cifs_inode;
245 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, SLAB_KERNEL);
246 if (!cifs_inode)
247 return NULL;
248 cifs_inode->cifsAttrs = 0x20; /* default */
249 atomic_set(&cifs_inode->inUse, 0);
250 cifs_inode->time = 0;
251 /* Until the file is open and we have gotten oplock
252 info back from the server, can not assume caching of
253 file data or metadata */
254 cifs_inode->clientCanCacheRead = FALSE;
255 cifs_inode->clientCanCacheAll = FALSE;
1da177e4 256 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
e30dcf3a 257 cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;
1da177e4
LT		 258 INIT_LIST_HEAD(&cifs_inode->openFileList);
259 return &cifs_inode->vfs_inode;
260}
261
262static void
263cifs_destroy_inode(struct inode *inode)
264{
265 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
266}
267
268/*
269 * cifs_show_options() is for displaying mount options in /proc/mounts.
270 * Not all settable options are displayed but most of the important
271 * ones are.
272 */
273static int
274cifs_show_options(struct seq_file *s, struct vfsmount *m)
275{
276 struct cifs_sb_info *cifs_sb;
277
278 cifs_sb = CIFS_SB(m->mnt_sb);
279
280 if (cifs_sb) {
281 if (cifs_sb->tcon) {
282 seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
283 if (cifs_sb->tcon->ses) {
284 if (cifs_sb->tcon->ses->userName)
285 seq_printf(s, ",username=%s",
286 cifs_sb->tcon->ses->userName);
287 if(cifs_sb->tcon->ses->domainName)
288 seq_printf(s, ",domain=%s",
289 cifs_sb->tcon->ses->domainName);
290 }
291 }
292 seq_printf(s, ",rsize=%d",cifs_sb->rsize);
293 seq_printf(s, ",wsize=%d",cifs_sb->wsize);
294 }
295 return 0;
296}
297
298#ifdef CONFIG_CIFS_QUOTA
299int cifs_xquota_set(struct super_block * sb, int quota_type, qid_t qid,
300 struct fs_disk_quota * pdquota)
301{
302 int xid;
303 int rc = 0;
304 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
305 struct cifsTconInfo *pTcon;
306
307 if(cifs_sb)
308 pTcon = cifs_sb->tcon;
309 else
310 return -EIO;
311
312
313 xid = GetXid();
314 if(pTcon) {
315 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
316 } else {
317 return -EIO;
318 }
319
320 FreeXid(xid);
321 return rc;
322}
323
324int cifs_xquota_get(struct super_block * sb, int quota_type, qid_t qid,
325 struct fs_disk_quota * pdquota)
326{
327 int xid;
328 int rc = 0;
329 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
330 struct cifsTconInfo *pTcon;
331
332 if(cifs_sb)
333 pTcon = cifs_sb->tcon;
334 else
335 return -EIO;
336
337 xid = GetXid();
338 if(pTcon) {
339 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
340 } else {
341 rc = -EIO;
342 }
343
344 FreeXid(xid);
345 return rc;
346}
347
348int cifs_xstate_set(struct super_block * sb, unsigned int flags, int operation)
349{
350 int xid;
351 int rc = 0;
352 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
353 struct cifsTconInfo *pTcon;
354
355 if(cifs_sb)
356 pTcon = cifs_sb->tcon;
357 else
358 return -EIO;
359
360 xid = GetXid();
361 if(pTcon) {
362 cFYI(1,("flags: 0x%x operation: 0x%x",flags,operation));
363 } else {
364 rc = -EIO;
365 }
366
367 FreeXid(xid);
368 return rc;
369}
370
371int cifs_xstate_get(struct super_block * sb, struct fs_quota_stat *qstats)
372{
373 int xid;
374 int rc = 0;
375 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
376 struct cifsTconInfo *pTcon;
377
378 if(cifs_sb) {
379 pTcon = cifs_sb->tcon;
380 } else {
381 return -EIO;
382 }
383 xid = GetXid();
384 if(pTcon) {
385 cFYI(1,("pqstats %p",qstats));
386 } else {
387 rc = -EIO;
388 }
389
390 FreeXid(xid);
391 return rc;
392}
393
394static struct quotactl_ops cifs_quotactl_ops = {
395 .set_xquota = cifs_xquota_set,
396 .get_xquota = cifs_xquota_set,
397 .set_xstate = cifs_xstate_set,
398 .get_xstate = cifs_xstate_get,
399};
400#endif
401
8b512d9a 402static void cifs_umount_begin(struct vfsmount * vfsmnt, int flags)
68058e75 403{
5e1253b5 404 struct cifs_sb_info *cifs_sb;
9e2e85f8 405 struct cifsTconInfo * tcon;
68058e75 406
8b512d9a
TM		 407 if (!(flags & MNT_FORCE))
408 return;
409 cifs_sb = CIFS_SB(vfsmnt->mnt_sb);
5e1253b5 410 if(cifs_sb == NULL)
9e2e85f8
SF		 411 return;
412
413 tcon = cifs_sb->tcon;
414 if(tcon == NULL)
415 return;
5e1253b5
SF		 416 down(&tcon->tconSem);
417 if (atomic_read(&tcon->useCount) == 1)
418 tcon->tidStatus = CifsExiting;
419 up(&tcon->tconSem);
420
3a5ff61c 421 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
7b7abfe3 422 /* cancel_notify_requests(tcon); */
9e2e85f8 423 if(tcon->ses && tcon->ses->server)
5e1253b5 424 {
7b7abfe3 425 cFYI(1,("wake up tasks now - umount begin not complete"));
9e2e85f8 426 wake_up_all(&tcon->ses->server->request_q);
6ab16d24
SF		 427 wake_up_all(&tcon->ses->server->response_q);
428 msleep(1); /* yield */
429 /* we have to kick the requests once more */
430 wake_up_all(&tcon->ses->server->response_q);
431 msleep(1);
5e1253b5
SF		 432 }
433/* BB FIXME - finish add checks for tidStatus BB */
68058e75
SF		 434
435 return;
436}
68058e75 437
1da177e4
LT		 438static int cifs_remount(struct super_block *sb, int *flags, char *data)
439{
440 *flags |= MS_NODIRATIME;
441 return 0;
442}
443
444struct super_operations cifs_super_ops = {
445 .read_inode = cifs_read_inode,
446 .put_super = cifs_put_super,
447 .statfs = cifs_statfs,
448 .alloc_inode = cifs_alloc_inode,
449 .destroy_inode = cifs_destroy_inode,
450/* .drop_inode = generic_delete_inode,
451 .delete_inode = cifs_delete_inode, *//* Do not need the above two functions
452 unless later we add lazy close of inodes or unless the kernel forgets to call
453 us with the same number of releases (closes) as opens */
454 .show_options = cifs_show_options,
7b7abfe3 455 .umount_begin = cifs_umount_begin,
1da177e4
LT		 456 .remount_fs = cifs_remount,
457};
458
454e2398 459static int
1da177e4 460cifs_get_sb(struct file_system_type *fs_type,
454e2398 461 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
1da177e4
LT		 462{
463 int rc;
464 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
465
466 cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
467
468 if (IS_ERR(sb))
454e2398 469 return PTR_ERR(sb);
1da177e4
LT		 470
471 sb->s_flags = flags;
472
9b04c997 473 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
1da177e4
LT		 474 if (rc) {
475 up_write(&sb->s_umount);
476 deactivate_super(sb);
454e2398 477 return rc;
1da177e4
LT		 478 }
479 sb->s_flags |= MS_ACTIVE;
454e2398 480 return simple_set_mnt(mnt, sb);
1da177e4
LT		 481}
482
87c89dd7
SF		 483static ssize_t cifs_file_writev(struct file *file, const struct iovec *iov,
484 unsigned long nr_segs, loff_t *ppos)
1da177e4 485{
87c89dd7
SF		 486 struct inode *inode = file->f_dentry->d_inode;
487 ssize_t written;
1da177e4 488
87c89dd7
SF		 489 written = generic_file_writev(file, iov, nr_segs, ppos);
490 if (!CIFS_I(inode)->clientCanCacheAll)
491 filemap_fdatawrite(inode->i_mapping);
492 return written;
1da177e4
LT		 493}
494
027445c3
BP		 495static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
496 unsigned long nr_segs, loff_t pos)
1da177e4 497{
87c89dd7 498 struct inode *inode = iocb->ki_filp->f_dentry->d_inode;
1da177e4
LT		 499 ssize_t written;
500
027445c3 501 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
87c89dd7
SF		 502 if (!CIFS_I(inode)->clientCanCacheAll)
503 filemap_fdatawrite(inode->i_mapping);
1da177e4
LT		 504 return written;
505}
506
c32a0b68
SF		 507static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
508{
509 /* origin == SEEK_END => we must revalidate the cached file length */
510 if (origin == 2) {
511 int retval = cifs_revalidate(file->f_dentry);
512 if (retval < 0)
513 return (loff_t)retval;
514 }
515 return remote_llseek(file, offset, origin);
516}
517
1da177e4
LT		 518static struct file_system_type cifs_fs_type = {
519 .owner = THIS_MODULE,
520 .name = "cifs",
521 .get_sb = cifs_get_sb,
522 .kill_sb = kill_anon_super,
523 /* .fs_flags */
524};
525struct inode_operations cifs_dir_inode_ops = {
526 .create = cifs_create,
527 .lookup = cifs_lookup,
528 .getattr = cifs_getattr,
529 .unlink = cifs_unlink,
530 .link = cifs_hardlink,
531 .mkdir = cifs_mkdir,
532 .rmdir = cifs_rmdir,
533 .rename = cifs_rename,
534 .permission = cifs_permission,
535/* revalidate:cifs_revalidate, */
536 .setattr = cifs_setattr,
537 .symlink = cifs_symlink,
538 .mknod = cifs_mknod,
539#ifdef CONFIG_CIFS_XATTR
540 .setxattr = cifs_setxattr,
541 .getxattr = cifs_getxattr,
542 .listxattr = cifs_listxattr,
543 .removexattr = cifs_removexattr,
544#endif
545};
546
547struct inode_operations cifs_file_inode_ops = {
548/* revalidate:cifs_revalidate, */
549 .setattr = cifs_setattr,
550 .getattr = cifs_getattr, /* do we need this anymore? */
551 .rename = cifs_rename,
552 .permission = cifs_permission,
553#ifdef CONFIG_CIFS_XATTR
554 .setxattr = cifs_setxattr,
555 .getxattr = cifs_getxattr,
556 .listxattr = cifs_listxattr,
557 .removexattr = cifs_removexattr,
558#endif
559};
560
561struct inode_operations cifs_symlink_inode_ops = {
562 .readlink = generic_readlink,
563 .follow_link = cifs_follow_link,
564 .put_link = cifs_put_link,
565 .permission = cifs_permission,
566 /* BB add the following two eventually */
567 /* revalidate: cifs_revalidate,
568 setattr: cifs_notify_change, *//* BB do we need notify change */
569#ifdef CONFIG_CIFS_XATTR
570 .setxattr = cifs_setxattr,
571 .getxattr = cifs_getxattr,
572 .listxattr = cifs_listxattr,
573 .removexattr = cifs_removexattr,
574#endif
575};
576
4b6f5d20 577const struct file_operations cifs_file_ops = {
87c89dd7
SF		 578 .read = do_sync_read,
579 .write = do_sync_write,
580 .readv = generic_file_readv,
581 .writev = cifs_file_writev,
582 .aio_read = generic_file_aio_read,
583 .aio_write = cifs_file_aio_write,
1da177e4
LT		 584 .open = cifs_open,
585 .release = cifs_close,
586 .lock = cifs_lock,
587 .fsync = cifs_fsync,
588 .flush = cifs_flush,
589 .mmap = cifs_file_mmap,
590 .sendfile = generic_file_sendfile,
c32a0b68 591 .llseek = cifs_llseek,
c67593a0
SF		 592#ifdef CONFIG_CIFS_POSIX
593 .ioctl = cifs_ioctl,
594#endif /* CONFIG_CIFS_POSIX */
595
1da177e4 596#ifdef CONFIG_CIFS_EXPERIMENTAL
1da177e4
LT		 597 .dir_notify = cifs_dir_notify,
598#endif /* CONFIG_CIFS_EXPERIMENTAL */
599};
600
4b6f5d20 601const struct file_operations cifs_file_direct_ops = {
1da177e4
LT		 602 /* no mmap, no aio, no readv -
603 BB reevaluate whether they can be done with directio, no cache */
604 .read = cifs_user_read,
605 .write = cifs_user_write,
606 .open = cifs_open,
607 .release = cifs_close,
608 .lock = cifs_lock,
609 .fsync = cifs_fsync,
610 .flush = cifs_flush,
611 .sendfile = generic_file_sendfile, /* BB removeme BB */
c67593a0
SF		 612#ifdef CONFIG_CIFS_POSIX
613 .ioctl = cifs_ioctl,
614#endif /* CONFIG_CIFS_POSIX */
c32a0b68 615 .llseek = cifs_llseek,
1da177e4
LT		 616#ifdef CONFIG_CIFS_EXPERIMENTAL
617 .dir_notify = cifs_dir_notify,
618#endif /* CONFIG_CIFS_EXPERIMENTAL */
619};
4b6f5d20 620const struct file_operations cifs_file_nobrl_ops = {
87c89dd7
SF		 621 .read = do_sync_read,
622 .write = do_sync_write,
623 .readv = generic_file_readv,
624 .writev = cifs_file_writev,
625 .aio_read = generic_file_aio_read,
626 .aio_write = cifs_file_aio_write,
627 .open = cifs_open,
628 .release = cifs_close,
629 .fsync = cifs_fsync,
630 .flush = cifs_flush,
631 .mmap = cifs_file_mmap,
632 .sendfile = generic_file_sendfile,
c32a0b68 633 .llseek = cifs_llseek,
8b94bcb9 634#ifdef CONFIG_CIFS_POSIX
87c89dd7 635 .ioctl = cifs_ioctl,
8b94bcb9
SF		 636#endif /* CONFIG_CIFS_POSIX */
637
638#ifdef CONFIG_CIFS_EXPERIMENTAL
87c89dd7 639 .dir_notify = cifs_dir_notify,
8b94bcb9
SF		 640#endif /* CONFIG_CIFS_EXPERIMENTAL */
641};
642
4b6f5d20 643const struct file_operations cifs_file_direct_nobrl_ops = {
87c89dd7
SF		 644 /* no mmap, no aio, no readv -
645 BB reevaluate whether they can be done with directio, no cache */
646 .read = cifs_user_read,
647 .write = cifs_user_write,
648 .open = cifs_open,
649 .release = cifs_close,
650 .fsync = cifs_fsync,
651 .flush = cifs_flush,
652 .sendfile = generic_file_sendfile, /* BB removeme BB */
8b94bcb9 653#ifdef CONFIG_CIFS_POSIX
87c89dd7 654 .ioctl = cifs_ioctl,
8b94bcb9 655#endif /* CONFIG_CIFS_POSIX */
c32a0b68 656 .llseek = cifs_llseek,
8b94bcb9 657#ifdef CONFIG_CIFS_EXPERIMENTAL
87c89dd7 658 .dir_notify = cifs_dir_notify,
8b94bcb9
SF		 659#endif /* CONFIG_CIFS_EXPERIMENTAL */
660};
1da177e4 661
4b6f5d20 662const struct file_operations cifs_dir_ops = {
1da177e4
LT		 663 .readdir = cifs_readdir,
664 .release = cifs_closedir,
665 .read = generic_read_dir,
666#ifdef CONFIG_CIFS_EXPERIMENTAL
667 .dir_notify = cifs_dir_notify,
668#endif /* CONFIG_CIFS_EXPERIMENTAL */
f28ac91b 669 .ioctl = cifs_ioctl,
1da177e4
LT		 670};
671
672static void
673cifs_init_once(void *inode, kmem_cache_t * cachep, unsigned long flags)
674{
675 struct cifsInodeInfo *cifsi = inode;
676
677 if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
678 SLAB_CTOR_CONSTRUCTOR) {
679 inode_init_once(&cifsi->vfs_inode);
680 INIT_LIST_HEAD(&cifsi->lockList);
681 }
682}
683
684static int
685cifs_init_inodecache(void)
686{
687 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
688 sizeof (struct cifsInodeInfo),
fffb60f9
PJ		 689 0, (SLAB_RECLAIM_ACCOUNT|
690 SLAB_MEM_SPREAD),
1da177e4
LT		 691 cifs_init_once, NULL);
692 if (cifs_inode_cachep == NULL)
693 return -ENOMEM;
694
695 return 0;
696}
697
698static void
699cifs_destroy_inodecache(void)
700{
1a1d92c1 701 kmem_cache_destroy(cifs_inode_cachep);
1da177e4
LT		 702}
703
704static int
705cifs_init_request_bufs(void)
706{
707 if(CIFSMaxBufSize < 8192) {
708 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
709 Unicode path name has to fit in any SMB/CIFS path based frames */
710 CIFSMaxBufSize = 8192;
711 } else if (CIFSMaxBufSize > 1024*127) {
712 CIFSMaxBufSize = 1024 * 127;
713 } else {
714 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
715 }
716/* cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
717 cifs_req_cachep = kmem_cache_create("cifs_request",
718 CIFSMaxBufSize +
719 MAX_CIFS_HDR_SIZE, 0,
720 SLAB_HWCACHE_ALIGN, NULL, NULL);
721 if (cifs_req_cachep == NULL)
722 return -ENOMEM;
723
724 if(cifs_min_rcv < 1)
725 cifs_min_rcv = 1;
726 else if (cifs_min_rcv > 64) {
727 cifs_min_rcv = 64;
728 cERROR(1,("cifs_min_rcv set to maximum (64)"));
729 }
730
93d2341c
MD		 731 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
732 cifs_req_cachep);
1da177e4
LT		 733
734 if(cifs_req_poolp == NULL) {
735 kmem_cache_destroy(cifs_req_cachep);
736 return -ENOMEM;
737 }
ec637e3f 738 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1da177e4
LT		 739 almost all handle based requests (but not write response, nor is it
740 sufficient for path based requests). A smaller size would have
741 been more efficient (compacting multiple slab items on one 4k page)
742 for the case in which debug was on, but this larger size allows
743 more SMBs to use small buffer alloc and is still much more
744 efficient to alloc 1 per page off the slab compared to 17K (5page)
745 alloc of large cifs buffers even when page debugging is on */
746 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
ec637e3f
SF		 747 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
748 NULL, NULL);
1da177e4
LT		 749 if (cifs_sm_req_cachep == NULL) {
750 mempool_destroy(cifs_req_poolp);
751 kmem_cache_destroy(cifs_req_cachep);
752 return -ENOMEM;
753 }
754
755 if(cifs_min_small < 2)
756 cifs_min_small = 2;
757 else if (cifs_min_small > 256) {
758 cifs_min_small = 256;
759 cFYI(1,("cifs_min_small set to maximum (256)"));
760 }
761
93d2341c
MD		 762 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
763 cifs_sm_req_cachep);
1da177e4
LT		 764
765 if(cifs_sm_req_poolp == NULL) {
766 mempool_destroy(cifs_req_poolp);
767 kmem_cache_destroy(cifs_req_cachep);
768 kmem_cache_destroy(cifs_sm_req_cachep);
769 return -ENOMEM;
770 }
771
772 return 0;
773}
774
775static void
776cifs_destroy_request_bufs(void)
777{
778 mempool_destroy(cifs_req_poolp);
1a1d92c1 779 kmem_cache_destroy(cifs_req_cachep);
1da177e4 780 mempool_destroy(cifs_sm_req_poolp);
1a1d92c1 781 kmem_cache_destroy(cifs_sm_req_cachep);
1da177e4
LT		 782}
783
784static int
785cifs_init_mids(void)
786{
787 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
788 sizeof (struct mid_q_entry), 0,
789 SLAB_HWCACHE_ALIGN, NULL, NULL);
790 if (cifs_mid_cachep == NULL)
791 return -ENOMEM;
792
93d2341c
MD		 793 /* 3 is a reasonable minimum number of simultaneous operations */
794 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1da177e4
LT		 795 if(cifs_mid_poolp == NULL) {
796 kmem_cache_destroy(cifs_mid_cachep);
797 return -ENOMEM;
798 }
799
800 cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
801 sizeof (struct oplock_q_entry), 0,
802 SLAB_HWCACHE_ALIGN, NULL, NULL);
803 if (cifs_oplock_cachep == NULL) {
804 kmem_cache_destroy(cifs_mid_cachep);
805 mempool_destroy(cifs_mid_poolp);
806 return -ENOMEM;
807 }
808
809 return 0;
810}
811
812static void
813cifs_destroy_mids(void)
814{
815 mempool_destroy(cifs_mid_poolp);
1a1d92c1
AD		 816 kmem_cache_destroy(cifs_mid_cachep);
817 kmem_cache_destroy(cifs_oplock_cachep);
1da177e4
LT		 818}
819
820static int cifs_oplock_thread(void * dummyarg)
821{
822 struct oplock_q_entry * oplock_item;
823 struct cifsTconInfo *pTcon;
824 struct inode * inode;
825 __u16 netfid;
826 int rc;
827
1da177e4 828 do {
ede1327e
SF		 829 if (try_to_freeze())
830 continue;
1da177e4 831
1da177e4
LT		 832 spin_lock(&GlobalMid_Lock);
833 if(list_empty(&GlobalOplock_Q)) {
834 spin_unlock(&GlobalMid_Lock);
835 set_current_state(TASK_INTERRUPTIBLE);
836 schedule_timeout(39*HZ);
837 } else {
838 oplock_item = list_entry(GlobalOplock_Q.next,
839 struct oplock_q_entry, qhead);
840 if(oplock_item) {
841 cFYI(1,("found oplock item to write out"));
842 pTcon = oplock_item->tcon;
843 inode = oplock_item->pinode;
844 netfid = oplock_item->netfid;
845 spin_unlock(&GlobalMid_Lock);
846 DeleteOplockQEntry(oplock_item);
847 /* can not grab inode sem here since it would
848 deadlock when oplock received on delete
1b1dcc1b 849 since vfs_unlink holds the i_mutex across
1da177e4 850 the call */
1b1dcc1b 851 /* mutex_lock(&inode->i_mutex);*/
1da177e4
LT		 852 if (S_ISREG(inode->i_mode)) {
853 rc = filemap_fdatawrite(inode->i_mapping);
854 if(CIFS_I(inode)->clientCanCacheRead == 0) {
855 filemap_fdatawait(inode->i_mapping);
856 invalidate_remote_inode(inode);
857 }
858 } else
859 rc = 0;
1b1dcc1b 860 /* mutex_unlock(&inode->i_mutex);*/
1da177e4
LT		 861 if (rc)
862 CIFS_I(inode)->write_behind_rc = rc;
863 cFYI(1,("Oplock flush inode %p rc %d",inode,rc));
864
865 /* releasing a stale oplock after recent reconnection
866 of smb session using a now incorrect file
867 handle is not a data integrity issue but do
868 not bother sending an oplock release if session
869 to server still is disconnected since oplock
870 already released by the server in that case */
871 if(pTcon->tidStatus != CifsNeedReconnect) {
872 rc = CIFSSMBLock(0, pTcon, netfid,
873 0 /* len */ , 0 /* offset */, 0,
874 0, LOCKING_ANDX_OPLOCK_RELEASE,
875 0 /* wait flag */);
876 cFYI(1,("Oplock release rc = %d ",rc));
877 }
878 } else
879 spin_unlock(&GlobalMid_Lock);
68058e75
SF		 880 set_current_state(TASK_INTERRUPTIBLE);
881 schedule_timeout(1); /* yield in case q were corrupt */
1da177e4 882 }
45af7a0f
SF		 883 } while (!kthread_should_stop());
884
885 return 0;
1da177e4
LT		 886}
887
8d0d5094
SF		 888static int cifs_dnotify_thread(void * dummyarg)
889{
6ab16d24
SF		 890 struct list_head *tmp;
891 struct cifsSesInfo *ses;
892
8d0d5094 893 do {
0fd1ffe0 894 if (try_to_freeze())
16abbecd 895 continue;
8d0d5094 896 set_current_state(TASK_INTERRUPTIBLE);
6ab16d24
SF		 897 schedule_timeout(15*HZ);
898 read_lock(&GlobalSMBSeslock);
899 /* check if any stuck requests that need
900 to be woken up and wakeq so the
901 thread can wake up and error out */
902 list_for_each(tmp, &GlobalSMBSessionList) {
903 ses = list_entry(tmp, struct cifsSesInfo,
904 cifsSessionList);
905 if(ses && ses->server &&
2a138ebb 906 atomic_read(&ses->server->inFlight))
6ab16d24
SF		 907 wake_up_all(&ses->server->response_q);
908 }
909 read_unlock(&GlobalSMBSeslock);
45af7a0f
SF		 910 } while (!kthread_should_stop());
911
912 return 0;
1da177e4
LT		 913}
914
915static int __init
916init_cifs(void)
917{
918 int rc = 0;
919#ifdef CONFIG_PROC_FS
920 cifs_proc_init();
921#endif
922 INIT_LIST_HEAD(&GlobalServerList); /* BB not implemented yet */
923 INIT_LIST_HEAD(&GlobalSMBSessionList);
924 INIT_LIST_HEAD(&GlobalTreeConnectionList);
925 INIT_LIST_HEAD(&GlobalOplock_Q);
4ca9c190
SF		 926#ifdef CONFIG_CIFS_EXPERIMENTAL
927 INIT_LIST_HEAD(&GlobalDnotifyReqList);
928 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
929#endif
1da177e4
LT		 930/*
931 * Initialize Global counters
932 */
933 atomic_set(&sesInfoAllocCount, 0);
934 atomic_set(&tconInfoAllocCount, 0);
935 atomic_set(&tcpSesAllocCount,0);
936 atomic_set(&tcpSesReconnectCount, 0);
937 atomic_set(&tconInfoReconnectCount, 0);
938
939 atomic_set(&bufAllocCount, 0);
4498eed5
SF		 940 atomic_set(&smBufAllocCount, 0);
941#ifdef CONFIG_CIFS_STATS2
942 atomic_set(&totBufAllocCount, 0);
943 atomic_set(&totSmBufAllocCount, 0);
944#endif /* CONFIG_CIFS_STATS2 */
945
1da177e4
LT		 946 atomic_set(&midCount, 0);
947 GlobalCurrentXid = 0;
948 GlobalTotalActiveXid = 0;
949 GlobalMaxActiveXid = 0;
950 rwlock_init(&GlobalSMBSeslock);
951 spin_lock_init(&GlobalMid_Lock);
952
953 if(cifs_max_pending < 2) {
954 cifs_max_pending = 2;
955 cFYI(1,("cifs_max_pending set to min of 2"));
956 } else if(cifs_max_pending > 256) {
957 cifs_max_pending = 256;
958 cFYI(1,("cifs_max_pending set to max of 256"));
959 }
960
961 rc = cifs_init_inodecache();
45af7a0f
SF		 962 if (rc)
963 goto out_clean_proc;
964
965 rc = cifs_init_mids();
966 if (rc)
967 goto out_destroy_inodecache;
968
969 rc = cifs_init_request_bufs();
970 if (rc)
971 goto out_destroy_mids;
972
973 rc = register_filesystem(&cifs_fs_type);
974 if (rc)
975 goto out_destroy_request_bufs;
976
977 oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
978 if (IS_ERR(oplockThread)) {
979 rc = PTR_ERR(oplockThread);
980 cERROR(1,("error %d create oplock thread", rc));
981 goto out_unregister_filesystem;
1da177e4 982 }
45af7a0f
SF		 983
984 dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
985 if (IS_ERR(dnotifyThread)) {
986 rc = PTR_ERR(dnotifyThread);
987 cERROR(1,("error %d create dnotify thread", rc));
988 goto out_stop_oplock_thread;
989 }
990
991 return 0;
992
993 out_stop_oplock_thread:
994 kthread_stop(oplockThread);
995 out_unregister_filesystem:
996 unregister_filesystem(&cifs_fs_type);
997 out_destroy_request_bufs:
998 cifs_destroy_request_bufs();
999 out_destroy_mids:
1000 cifs_destroy_mids();
1001 out_destroy_inodecache:
1002 cifs_destroy_inodecache();
1003 out_clean_proc:
1da177e4
LT		 1004#ifdef CONFIG_PROC_FS
1005 cifs_proc_clean();
1006#endif
1007 return rc;
1008}
1009
1010static void __exit
1011exit_cifs(void)
1012{
1013 cFYI(0, ("In unregister ie exit_cifs"));
1014#ifdef CONFIG_PROC_FS
1015 cifs_proc_clean();
1016#endif
1017 unregister_filesystem(&cifs_fs_type);
1018 cifs_destroy_inodecache();
1019 cifs_destroy_mids();
1020 cifs_destroy_request_bufs();
45af7a0f
SF		 1021 kthread_stop(oplockThread);
1022 kthread_stop(dnotifyThread);
1da177e4
LT		 1023}
1024
1025MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1026MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1027MODULE_DESCRIPTION
1028 ("VFS to access servers complying with the SNIA CIFS Specification e.g. Samba and Windows");
1029MODULE_VERSION(CIFS_VERSION);
1030module_init(init_cifs)
1031module_exit(exit_cifs)
kernel source for telekom puls (alcatel/mediatek)