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