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