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