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