]> bbs.cooldavid.org Git - net-next-2.6.git/blame - fs/cifs/cifsfs.c
cifs: temporarily rename cifs_sb->tcon to ptcon to catch stragglers
[net-next-2.6.git] / fs / cifs / cifsfs.c
CommitLineData
1da177e4
LT
1/*
2 * fs/cifs/cifsfs.c
3 *
2b280fab 4 * Copyright (C) International Business Machines Corp., 2002,2008
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>
67e55205 38#include <linux/smp_lock.h>
3eb9a889 39#include <net/ipv6.h>
1da177e4
LT
40#include "cifsfs.h"
41#include "cifspdu.h"
42#define DECLARE_GLOBALS_HERE
43#include "cifsglob.h"
44#include "cifsproto.h"
45#include "cifs_debug.h"
46#include "cifs_fs_sb.h"
47#include <linux/mm.h>
84a15b93 48#include <linux/key-type.h>
e545937a 49#include "cifs_spnego.h"
f579cf3c 50#include "fscache.h"
1da177e4
LT
51#define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
52
1da177e4
LT
53int cifsFYI = 0;
54int cifsERROR = 1;
55int traceSMB = 0;
56unsigned int oplockEnabled = 1;
57unsigned int experimEnabled = 0;
58unsigned int linuxExtEnabled = 1;
59unsigned int lookupCacheEnabled = 1;
60unsigned int multiuser_mount = 0;
04912d6a 61unsigned int global_secflags = CIFSSEC_DEF;
3979877e 62/* unsigned int ntlmv2_support = 0; */
1da177e4 63unsigned int sign_CIFS_PDUs = 1;
ee9b6d61 64static const struct super_operations cifs_super_ops;
1da177e4
LT
65unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
66module_param(CIFSMaxBufSize, int, 0);
63135e08
SF
67MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
68 "Default: 16384 Range: 8192 to 130048");
1da177e4
LT
69unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
70module_param(cifs_min_rcv, int, 0);
63135e08
SF
71MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
72 "1 to 64");
1da177e4
LT
73unsigned int cifs_min_small = 30;
74module_param(cifs_min_small, int, 0);
63135e08
SF
75MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
76 "Range: 2 to 256");
1da177e4
LT
77unsigned int cifs_max_pending = CIFS_MAX_REQ;
78module_param(cifs_max_pending, int, 0);
63135e08
SF
79MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
80 "Default: 50 Range: 2 to 256");
1da177e4 81
1da177e4
LT
82extern mempool_t *cifs_sm_req_poolp;
83extern mempool_t *cifs_req_poolp;
84extern mempool_t *cifs_mid_poolp;
85
1da177e4
LT
86static int
87cifs_read_super(struct super_block *sb, void *data,
88 const char *devname, int silent)
89{
90 struct inode *inode;
91 struct cifs_sb_info *cifs_sb;
92 int rc = 0;
50c2f753 93
1b2b2126
SF
94 /* BB should we make this contingent on mount parm? */
95 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
790fe579 96 sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
1da177e4 97 cifs_sb = CIFS_SB(sb);
4523cc30 98 if (cifs_sb == NULL)
1da177e4 99 return -ENOMEM;
1da177e4 100
8044f7f4
JA
101 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
102 if (rc) {
103 kfree(cifs_sb);
104 return rc;
105 }
106
e6ab1582
IM
107#ifdef CONFIG_CIFS_DFS_UPCALL
108 /* copy mount params to sb for use in submounts */
109 /* BB: should we move this after the mount so we
110 * do not have to do the copy on failed mounts?
111 * BB: May be it is better to do simple copy before
112 * complex operation (mount), and in case of fail
113 * just exit instead of doing mount and attempting
114 * undo it if this copy fails?*/
79ee9a8b
SF
115 if (data) {
116 int len = strlen(data);
117 cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
118 if (cifs_sb->mountdata == NULL) {
8044f7f4 119 bdi_destroy(&cifs_sb->bdi);
79ee9a8b
SF
120 kfree(sb->s_fs_info);
121 sb->s_fs_info = NULL;
122 return -ENOMEM;
123 }
124 strncpy(cifs_sb->mountdata, data, len + 1);
125 cifs_sb->mountdata[len] = '\0';
e6ab1582 126 }
e6ab1582
IM
127#endif
128
1da177e4
LT
129 rc = cifs_mount(sb, cifs_sb, data, devname);
130
131 if (rc) {
132 if (!silent)
b6b38f70 133 cERROR(1, "cifs_mount failed w/return code = %d", rc);
1da177e4
LT
134 goto out_mount_failed;
135 }
136
137 sb->s_magic = CIFS_MAGIC_NUMBER;
138 sb->s_op = &cifs_super_ops;
8044f7f4 139 sb->s_bdi = &cifs_sb->bdi;
1da177e4
LT
140 sb->s_blocksize = CIFS_MAX_MSGSIZE;
141 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
bd433d4c 142 inode = cifs_root_iget(sb, ROOT_I);
1da177e4 143
ce634ab2
DH
144 if (IS_ERR(inode)) {
145 rc = PTR_ERR(inode);
146 inode = NULL;
1da177e4
LT
147 goto out_no_root;
148 }
149
150 sb->s_root = d_alloc_root(inode);
151
152 if (!sb->s_root) {
153 rc = -ENOMEM;
154 goto out_no_root;
155 }
50c2f753 156
7521a3c5
SF
157#ifdef CONFIG_CIFS_EXPERIMENTAL
158 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
b6b38f70 159 cFYI(1, "export ops supported");
7521a3c5
SF
160 sb->s_export_op = &cifs_export_ops;
161 }
162#endif /* EXPERIMENTAL */
1da177e4
LT
163
164 return 0;
165
166out_no_root:
b6b38f70 167 cERROR(1, "cifs_read_super: get root inode failed");
1da177e4
LT
168 if (inode)
169 iput(inode);
54b4602d 170
2c731afb 171 cifs_umount(sb, cifs_sb);
1da177e4
LT
172
173out_mount_failed:
4523cc30 174 if (cifs_sb) {
e6ab1582
IM
175#ifdef CONFIG_CIFS_DFS_UPCALL
176 if (cifs_sb->mountdata) {
177 kfree(cifs_sb->mountdata);
178 cifs_sb->mountdata = NULL;
179 }
180#endif
6d729e44 181 unload_nls(cifs_sb->local_nls);
8044f7f4 182 bdi_destroy(&cifs_sb->bdi);
1da177e4
LT
183 kfree(cifs_sb);
184 }
185 return rc;
186}
187
188static void
189cifs_put_super(struct super_block *sb)
190{
191 int rc = 0;
192 struct cifs_sb_info *cifs_sb;
193
b6b38f70 194 cFYI(1, "In cifs_put_super");
1da177e4 195 cifs_sb = CIFS_SB(sb);
4523cc30 196 if (cifs_sb == NULL) {
b6b38f70 197 cFYI(1, "Empty cifs superblock info passed to unmount");
1da177e4
LT
198 return;
199 }
6cfd0148
CH
200
201 lock_kernel();
202
790fe579 203 rc = cifs_umount(sb, cifs_sb);
ad7a2926 204 if (rc)
b6b38f70 205 cERROR(1, "cifs_umount failed with return code %d", rc);
e6ab1582
IM
206#ifdef CONFIG_CIFS_DFS_UPCALL
207 if (cifs_sb->mountdata) {
208 kfree(cifs_sb->mountdata);
209 cifs_sb->mountdata = NULL;
210 }
211#endif
212
1da177e4 213 unload_nls(cifs_sb->local_nls);
8044f7f4 214 bdi_destroy(&cifs_sb->bdi);
1da177e4 215 kfree(cifs_sb);
6cfd0148
CH
216
217 unlock_kernel();
1da177e4
LT
218}
219
220static int
726c3342 221cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
1da177e4 222{
726c3342 223 struct super_block *sb = dentry->d_sb;
39da9847 224 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
a6e8a845 225 struct cifsTconInfo *tcon = cifs_sb_tcon(cifs_sb);
c81156dd 226 int rc = -EOPNOTSUPP;
39da9847 227 int xid;
1da177e4
LT
228
229 xid = GetXid();
230
1da177e4
LT
231 buf->f_type = CIFS_MAGIC_NUMBER;
232
39da9847
SF
233 /*
234 * PATH_MAX may be too long - it would presumably be total path,
235 * but note that some servers (includinng Samba 3) have a shorter
236 * maximum path.
237 *
238 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
239 */
240 buf->f_namelen = PATH_MAX;
1da177e4
LT
241 buf->f_files = 0; /* undefined */
242 buf->f_ffree = 0; /* unlimited */
243
39da9847
SF
244 /*
245 * We could add a second check for a QFS Unix capability bit
246 */
247 if ((tcon->ses->capabilities & CAP_UNIX) &&
248 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
249 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
250
251 /*
252 * Only need to call the old QFSInfo if failed on newer one,
253 * e.g. by OS/2.
254 **/
255 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
256 rc = CIFSSMBQFSInfo(xid, tcon, buf);
257
258 /*
259 * Some old Windows servers also do not support level 103, retry with
260 * older level one if old server failed the previous call or we
261 * bypassed it because we detected that this was an older LANMAN sess
262 */
4523cc30 263 if (rc)
39da9847
SF
264 rc = SMBOldQFSInfo(xid, tcon, buf);
265
1da177e4 266 FreeXid(xid);
39da9847 267 return 0;
1da177e4
LT
268}
269
e6305c43 270static int cifs_permission(struct inode *inode, int mask)
1da177e4
LT
271{
272 struct cifs_sb_info *cifs_sb;
273
274 cifs_sb = CIFS_SB(inode->i_sb);
275
f696a365
MS
276 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
277 if ((mask & MAY_EXEC) && !execute_ok(inode))
278 return -EACCES;
279 else
280 return 0;
281 } else /* file mode might have been restricted at mount time
50c2f753 282 on the client (above and beyond ACL on servers) for
1da177e4 283 servers which do not support setting and viewing mode bits,
50c2f753 284 so allowing client to check permissions is useful */
1da177e4
LT
285 return generic_permission(inode, mask, NULL);
286}
287
e18b890b
CL
288static struct kmem_cache *cifs_inode_cachep;
289static struct kmem_cache *cifs_req_cachep;
290static struct kmem_cache *cifs_mid_cachep;
e18b890b 291static struct kmem_cache *cifs_sm_req_cachep;
1da177e4
LT
292mempool_t *cifs_sm_req_poolp;
293mempool_t *cifs_req_poolp;
294mempool_t *cifs_mid_poolp;
295
296static struct inode *
297cifs_alloc_inode(struct super_block *sb)
298{
299 struct cifsInodeInfo *cifs_inode;
e94b1766 300 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
1da177e4
LT
301 if (!cifs_inode)
302 return NULL;
303 cifs_inode->cifsAttrs = 0x20; /* default */
1da177e4 304 cifs_inode->time = 0;
cea21805 305 cifs_inode->write_behind_rc = 0;
1da177e4
LT
306 /* Until the file is open and we have gotten oplock
307 info back from the server, can not assume caching of
308 file data or metadata */
4b18f2a9
SF
309 cifs_inode->clientCanCacheRead = false;
310 cifs_inode->clientCanCacheAll = false;
9a8165fc 311 cifs_inode->delete_pending = false;
df2cf170 312 cifs_inode->invalid_mapping = false;
1da177e4 313 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
fbec9ab9 314 cifs_inode->server_eof = 0;
50c2f753 315
1b2b2126
SF
316 /* Can not set i_flags here - they get immediately overwritten
317 to zero by the VFS */
318/* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
1da177e4
LT
319 INIT_LIST_HEAD(&cifs_inode->openFileList);
320 return &cifs_inode->vfs_inode;
321}
322
323static void
324cifs_destroy_inode(struct inode *inode)
325{
326 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
327}
328
9451a9a5 329static void
b57922d9 330cifs_evict_inode(struct inode *inode)
9451a9a5 331{
b57922d9
AV
332 truncate_inode_pages(&inode->i_data, 0);
333 end_writeback(inode);
9451a9a5
SJ
334 cifs_fscache_release_inode_cookie(inode);
335}
336
61f98ffd
JL
337static void
338cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
339{
340 seq_printf(s, ",addr=");
341
342 switch (server->addr.sockAddr.sin_family) {
343 case AF_INET:
344 seq_printf(s, "%pI4", &server->addr.sockAddr.sin_addr.s_addr);
345 break;
346 case AF_INET6:
347 seq_printf(s, "%pI6",
348 &server->addr.sockAddr6.sin6_addr.s6_addr);
349 if (server->addr.sockAddr6.sin6_scope_id)
350 seq_printf(s, "%%%u",
351 server->addr.sockAddr6.sin6_scope_id);
352 break;
353 default:
354 seq_printf(s, "(unknown)");
355 }
356}
357
1da177e4
LT
358/*
359 * cifs_show_options() is for displaying mount options in /proc/mounts.
360 * Not all settable options are displayed but most of the important
361 * ones are.
362 */
363static int
364cifs_show_options(struct seq_file *s, struct vfsmount *m)
365{
8e047d09 366 struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
a6e8a845 367 struct cifsTconInfo *tcon = cifs_sb_tcon(cifs_sb);
3eb9a889
BG
368 struct sockaddr *srcaddr;
369 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
8616e0fc 370
8e047d09 371 seq_printf(s, ",unc=%s", tcon->treeName);
8616e0fc
JL
372 if (tcon->ses->userName)
373 seq_printf(s, ",username=%s", tcon->ses->userName);
374 if (tcon->ses->domainName)
375 seq_printf(s, ",domain=%s", tcon->ses->domainName);
376
3eb9a889
BG
377 if (srcaddr->sa_family != AF_UNSPEC) {
378 struct sockaddr_in *saddr4;
379 struct sockaddr_in6 *saddr6;
380 saddr4 = (struct sockaddr_in *)srcaddr;
381 saddr6 = (struct sockaddr_in6 *)srcaddr;
382 if (srcaddr->sa_family == AF_INET6)
383 seq_printf(s, ",srcaddr=%pI6c",
384 &saddr6->sin6_addr);
385 else if (srcaddr->sa_family == AF_INET)
386 seq_printf(s, ",srcaddr=%pI4",
387 &saddr4->sin_addr.s_addr);
388 else
389 seq_printf(s, ",srcaddr=BAD-AF:%i",
390 (int)(srcaddr->sa_family));
391 }
392
8616e0fc 393 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
340481a3
JL
394 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
395 seq_printf(s, ",forceuid");
4486d6ed
JL
396 else
397 seq_printf(s, ",noforceuid");
340481a3 398
8616e0fc 399 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
340481a3
JL
400 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
401 seq_printf(s, ",forcegid");
4486d6ed
JL
402 else
403 seq_printf(s, ",noforcegid");
8616e0fc 404
61f98ffd 405 cifs_show_address(s, tcon->ses->server);
1da177e4 406
8616e0fc
JL
407 if (!tcon->unix_ext)
408 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
2b280fab
SF
409 cifs_sb->mnt_file_mode,
410 cifs_sb->mnt_dir_mode);
8616e0fc
JL
411 if (tcon->seal)
412 seq_printf(s, ",seal");
413 if (tcon->nocase)
414 seq_printf(s, ",nocase");
415 if (tcon->retry)
416 seq_printf(s, ",hard");
417 if (cifs_sb->prepath)
418 seq_printf(s, ",prepath=%s", cifs_sb->prepath);
419 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
420 seq_printf(s, ",posixpaths");
421 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
422 seq_printf(s, ",setuids");
423 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
424 seq_printf(s, ",serverino");
425 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
426 seq_printf(s, ",directio");
427 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
428 seq_printf(s, ",nouser_xattr");
429 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
430 seq_printf(s, ",mapchars");
431 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
432 seq_printf(s, ",sfu");
433 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
434 seq_printf(s, ",nobrl");
435 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
436 seq_printf(s, ",cifsacl");
437 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
438 seq_printf(s, ",dynperm");
439 if (m->mnt_sb->s_flags & MS_POSIXACL)
440 seq_printf(s, ",acl");
736a3320
SM
441 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
442 seq_printf(s, ",mfsymlinks");
8616e0fc
JL
443
444 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
445 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
446
1da177e4
LT
447 return 0;
448}
449
42faad99 450static void cifs_umount_begin(struct super_block *sb)
68058e75 451{
42faad99 452 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
50c2f753 453 struct cifsTconInfo *tcon;
68058e75 454
4523cc30 455 if (cifs_sb == NULL)
9e2e85f8
SF
456 return;
457
a6e8a845 458 tcon = cifs_sb_tcon(cifs_sb);
f1987b44
JL
459
460 read_lock(&cifs_tcp_ses_lock);
ad8034f1
SF
461 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
462 /* we have other mounts to same share or we have
463 already tried to force umount this and woken up
464 all waiting network requests, nothing to do */
465 read_unlock(&cifs_tcp_ses_lock);
466 return;
467 } else if (tcon->tc_count == 1)
5e1253b5 468 tcon->tidStatus = CifsExiting;
f1987b44 469 read_unlock(&cifs_tcp_ses_lock);
5e1253b5 470
3a5ff61c 471 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
7b7abfe3 472 /* cancel_notify_requests(tcon); */
50c2f753 473 if (tcon->ses && tcon->ses->server) {
b6b38f70 474 cFYI(1, "wake up tasks now - umount begin not complete");
9e2e85f8 475 wake_up_all(&tcon->ses->server->request_q);
6ab16d24
SF
476 wake_up_all(&tcon->ses->server->response_q);
477 msleep(1); /* yield */
478 /* we have to kick the requests once more */
479 wake_up_all(&tcon->ses->server->response_q);
480 msleep(1);
5e1253b5 481 }
68058e75
SF
482
483 return;
484}
68058e75 485
bf97d287
SF
486#ifdef CONFIG_CIFS_STATS2
487static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
488{
489 /* BB FIXME */
490 return 0;
491}
492#endif
493
1da177e4
LT
494static int cifs_remount(struct super_block *sb, int *flags, char *data)
495{
496 *flags |= MS_NODIRATIME;
497 return 0;
498}
499
45321ac5 500static int cifs_drop_inode(struct inode *inode)
12420ac3
JL
501{
502 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
503
45321ac5
AV
504 /* no serverino => unconditional eviction */
505 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
506 generic_drop_inode(inode);
12420ac3
JL
507}
508
ee9b6d61 509static const struct super_operations cifs_super_ops = {
1da177e4
LT
510 .put_super = cifs_put_super,
511 .statfs = cifs_statfs,
512 .alloc_inode = cifs_alloc_inode,
513 .destroy_inode = cifs_destroy_inode,
12420ac3 514 .drop_inode = cifs_drop_inode,
b57922d9 515 .evict_inode = cifs_evict_inode,
12420ac3
JL
516/* .delete_inode = cifs_delete_inode, */ /* Do not need above
517 function unless later we add lazy close of inodes or unless the
50c2f753
SF
518 kernel forgets to call us with the same number of releases (closes)
519 as opens */
1da177e4 520 .show_options = cifs_show_options,
7b7abfe3 521 .umount_begin = cifs_umount_begin,
1da177e4 522 .remount_fs = cifs_remount,
bf97d287 523#ifdef CONFIG_CIFS_STATS2
f46d3e11 524 .show_stats = cifs_show_stats,
bf97d287 525#endif
1da177e4
LT
526};
527
454e2398 528static int
1da177e4 529cifs_get_sb(struct file_system_type *fs_type,
454e2398 530 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
1da177e4
LT
531{
532 int rc;
533 struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
534
b6b38f70 535 cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
1da177e4
LT
536
537 if (IS_ERR(sb))
454e2398 538 return PTR_ERR(sb);
1da177e4
LT
539
540 sb->s_flags = flags;
541
9b04c997 542 rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
1da177e4 543 if (rc) {
6f5bbff9 544 deactivate_locked_super(sb);
454e2398 545 return rc;
1da177e4
LT
546 }
547 sb->s_flags |= MS_ACTIVE;
a3ec947c
SB
548 simple_set_mnt(mnt, sb);
549 return 0;
1da177e4
LT
550}
551
027445c3
BP
552static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
553 unsigned long nr_segs, loff_t pos)
1da177e4 554{
e6a00296 555 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
1da177e4
LT
556 ssize_t written;
557
027445c3 558 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
87c89dd7
SF
559 if (!CIFS_I(inode)->clientCanCacheAll)
560 filemap_fdatawrite(inode->i_mapping);
1da177e4
LT
561 return written;
562}
563
c32a0b68
SF
564static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
565{
566 /* origin == SEEK_END => we must revalidate the cached file length */
0889a944 567 if (origin == SEEK_END) {
030e9d81
SF
568 int retval;
569
570 /* some applications poll for the file length in this strange
571 way so we must seek to end on non-oplocked files by
572 setting the revalidate time to zero */
c33f8d32 573 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
030e9d81 574
abab095d 575 retval = cifs_revalidate_file(file);
c32a0b68
SF
576 if (retval < 0)
577 return (loff_t)retval;
578 }
9465efc9 579 return generic_file_llseek_unlocked(file, offset, origin);
c32a0b68
SF
580}
581
84210e91
SF
582static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
583{
584 /* note that this is called by vfs setlease with the BKL held
585 although I doubt that BKL is needed here in cifs */
586 struct inode *inode = file->f_path.dentry->d_inode;
ba00ba64 587 struct cifsFileInfo *cfile = file->private_data;
84210e91
SF
588
589 if (!(S_ISREG(inode->i_mode)))
590 return -EINVAL;
591
592 /* check if file is oplocked */
593 if (((arg == F_RDLCK) &&
594 (CIFS_I(inode)->clientCanCacheRead)) ||
595 ((arg == F_WRLCK) &&
596 (CIFS_I(inode)->clientCanCacheAll)))
597 return generic_setlease(file, arg, lease);
ba00ba64 598 else if (cfile->tcon->local_lease && !CIFS_I(inode)->clientCanCacheRead)
84210e91
SF
599 /* If the server claims to support oplock on this
600 file, then we still need to check oplock even
601 if the local_lease mount option is set, but there
602 are servers which do not support oplock for which
603 this mount option may be useful if the user
604 knows that the file won't be changed on the server
605 by anyone else */
606 return generic_setlease(file, arg, lease);
607 else
608 return -EAGAIN;
609}
84210e91 610
e6ab1582 611struct file_system_type cifs_fs_type = {
1da177e4
LT
612 .owner = THIS_MODULE,
613 .name = "cifs",
614 .get_sb = cifs_get_sb,
615 .kill_sb = kill_anon_super,
616 /* .fs_flags */
617};
754661f1 618const struct inode_operations cifs_dir_inode_ops = {
1da177e4
LT
619 .create = cifs_create,
620 .lookup = cifs_lookup,
621 .getattr = cifs_getattr,
622 .unlink = cifs_unlink,
623 .link = cifs_hardlink,
624 .mkdir = cifs_mkdir,
625 .rmdir = cifs_rmdir,
626 .rename = cifs_rename,
627 .permission = cifs_permission,
628/* revalidate:cifs_revalidate, */
629 .setattr = cifs_setattr,
630 .symlink = cifs_symlink,
631 .mknod = cifs_mknod,
632#ifdef CONFIG_CIFS_XATTR
633 .setxattr = cifs_setxattr,
634 .getxattr = cifs_getxattr,
635 .listxattr = cifs_listxattr,
636 .removexattr = cifs_removexattr,
637#endif
638};
639
754661f1 640const struct inode_operations cifs_file_inode_ops = {
1da177e4
LT
641/* revalidate:cifs_revalidate, */
642 .setattr = cifs_setattr,
643 .getattr = cifs_getattr, /* do we need this anymore? */
644 .rename = cifs_rename,
645 .permission = cifs_permission,
646#ifdef CONFIG_CIFS_XATTR
647 .setxattr = cifs_setxattr,
648 .getxattr = cifs_getxattr,
649 .listxattr = cifs_listxattr,
650 .removexattr = cifs_removexattr,
50c2f753 651#endif
1da177e4
LT
652};
653
754661f1 654const struct inode_operations cifs_symlink_inode_ops = {
50c2f753 655 .readlink = generic_readlink,
1da177e4
LT
656 .follow_link = cifs_follow_link,
657 .put_link = cifs_put_link,
658 .permission = cifs_permission,
659 /* BB add the following two eventually */
660 /* revalidate: cifs_revalidate,
661 setattr: cifs_notify_change, *//* BB do we need notify change */
662#ifdef CONFIG_CIFS_XATTR
663 .setxattr = cifs_setxattr,
664 .getxattr = cifs_getxattr,
665 .listxattr = cifs_listxattr,
666 .removexattr = cifs_removexattr,
50c2f753 667#endif
1da177e4
LT
668};
669
4b6f5d20 670const struct file_operations cifs_file_ops = {
87c89dd7
SF
671 .read = do_sync_read,
672 .write = do_sync_write,
87c89dd7
SF
673 .aio_read = generic_file_aio_read,
674 .aio_write = cifs_file_aio_write,
1da177e4
LT
675 .open = cifs_open,
676 .release = cifs_close,
677 .lock = cifs_lock,
678 .fsync = cifs_fsync,
679 .flush = cifs_flush,
680 .mmap = cifs_file_mmap,
5ffc4ef4 681 .splice_read = generic_file_splice_read,
c32a0b68 682 .llseek = cifs_llseek,
c67593a0 683#ifdef CONFIG_CIFS_POSIX
f9ddcca4 684 .unlocked_ioctl = cifs_ioctl,
c67593a0 685#endif /* CONFIG_CIFS_POSIX */
84210e91 686 .setlease = cifs_setlease,
1da177e4
LT
687};
688
4b6f5d20 689const struct file_operations cifs_file_direct_ops = {
a994b8fa 690 /* no aio, no readv -
1da177e4
LT
691 BB reevaluate whether they can be done with directio, no cache */
692 .read = cifs_user_read,
693 .write = cifs_user_write,
694 .open = cifs_open,
695 .release = cifs_close,
696 .lock = cifs_lock,
697 .fsync = cifs_fsync,
698 .flush = cifs_flush,
a994b8fa 699 .mmap = cifs_file_mmap,
5ffc4ef4 700 .splice_read = generic_file_splice_read,
c67593a0 701#ifdef CONFIG_CIFS_POSIX
f9ddcca4 702 .unlocked_ioctl = cifs_ioctl,
c67593a0 703#endif /* CONFIG_CIFS_POSIX */
c32a0b68 704 .llseek = cifs_llseek,
84210e91 705 .setlease = cifs_setlease,
1da177e4 706};
4b6f5d20 707const struct file_operations cifs_file_nobrl_ops = {
87c89dd7
SF
708 .read = do_sync_read,
709 .write = do_sync_write,
87c89dd7
SF
710 .aio_read = generic_file_aio_read,
711 .aio_write = cifs_file_aio_write,
712 .open = cifs_open,
713 .release = cifs_close,
714 .fsync = cifs_fsync,
715 .flush = cifs_flush,
716 .mmap = cifs_file_mmap,
5ffc4ef4 717 .splice_read = generic_file_splice_read,
c32a0b68 718 .llseek = cifs_llseek,
8b94bcb9 719#ifdef CONFIG_CIFS_POSIX
f9ddcca4 720 .unlocked_ioctl = cifs_ioctl,
8b94bcb9 721#endif /* CONFIG_CIFS_POSIX */
84210e91 722 .setlease = cifs_setlease,
8b94bcb9
SF
723};
724
4b6f5d20 725const struct file_operations cifs_file_direct_nobrl_ops = {
50c2f753 726 /* no mmap, no aio, no readv -
87c89dd7
SF
727 BB reevaluate whether they can be done with directio, no cache */
728 .read = cifs_user_read,
729 .write = cifs_user_write,
730 .open = cifs_open,
731 .release = cifs_close,
732 .fsync = cifs_fsync,
733 .flush = cifs_flush,
810627a0 734 .mmap = cifs_file_mmap,
5ffc4ef4 735 .splice_read = generic_file_splice_read,
8b94bcb9 736#ifdef CONFIG_CIFS_POSIX
f9ddcca4 737 .unlocked_ioctl = cifs_ioctl,
8b94bcb9 738#endif /* CONFIG_CIFS_POSIX */
c32a0b68 739 .llseek = cifs_llseek,
84210e91 740 .setlease = cifs_setlease,
8b94bcb9 741};
1da177e4 742
4b6f5d20 743const struct file_operations cifs_dir_ops = {
1da177e4
LT
744 .readdir = cifs_readdir,
745 .release = cifs_closedir,
746 .read = generic_read_dir,
f9ddcca4 747 .unlocked_ioctl = cifs_ioctl,
3222a3e5 748 .llseek = generic_file_llseek,
1da177e4
LT
749};
750
751static void
51cc5068 752cifs_init_once(void *inode)
1da177e4
LT
753{
754 struct cifsInodeInfo *cifsi = inode;
755
a35afb83
CL
756 inode_init_once(&cifsi->vfs_inode);
757 INIT_LIST_HEAD(&cifsi->lockList);
1da177e4
LT
758}
759
760static int
761cifs_init_inodecache(void)
762{
763 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
26f57364 764 sizeof(struct cifsInodeInfo),
fffb60f9
PJ
765 0, (SLAB_RECLAIM_ACCOUNT|
766 SLAB_MEM_SPREAD),
20c2df83 767 cifs_init_once);
1da177e4
LT
768 if (cifs_inode_cachep == NULL)
769 return -ENOMEM;
770
771 return 0;
772}
773
774static void
775cifs_destroy_inodecache(void)
776{
1a1d92c1 777 kmem_cache_destroy(cifs_inode_cachep);
1da177e4
LT
778}
779
780static int
781cifs_init_request_bufs(void)
782{
4523cc30 783 if (CIFSMaxBufSize < 8192) {
1da177e4
LT
784 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
785 Unicode path name has to fit in any SMB/CIFS path based frames */
786 CIFSMaxBufSize = 8192;
787 } else if (CIFSMaxBufSize > 1024*127) {
788 CIFSMaxBufSize = 1024 * 127;
789 } else {
790 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
791 }
b6b38f70 792/* cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
1da177e4
LT
793 cifs_req_cachep = kmem_cache_create("cifs_request",
794 CIFSMaxBufSize +
795 MAX_CIFS_HDR_SIZE, 0,
20c2df83 796 SLAB_HWCACHE_ALIGN, NULL);
1da177e4
LT
797 if (cifs_req_cachep == NULL)
798 return -ENOMEM;
799
4523cc30 800 if (cifs_min_rcv < 1)
1da177e4
LT
801 cifs_min_rcv = 1;
802 else if (cifs_min_rcv > 64) {
803 cifs_min_rcv = 64;
b6b38f70 804 cERROR(1, "cifs_min_rcv set to maximum (64)");
1da177e4
LT
805 }
806
93d2341c
MD
807 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
808 cifs_req_cachep);
1da177e4 809
4523cc30 810 if (cifs_req_poolp == NULL) {
1da177e4
LT
811 kmem_cache_destroy(cifs_req_cachep);
812 return -ENOMEM;
813 }
ec637e3f 814 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1da177e4
LT
815 almost all handle based requests (but not write response, nor is it
816 sufficient for path based requests). A smaller size would have
50c2f753 817 been more efficient (compacting multiple slab items on one 4k page)
1da177e4
LT
818 for the case in which debug was on, but this larger size allows
819 more SMBs to use small buffer alloc and is still much more
6dc0f87e 820 efficient to alloc 1 per page off the slab compared to 17K (5page)
1da177e4
LT
821 alloc of large cifs buffers even when page debugging is on */
822 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
6dc0f87e 823 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
20c2df83 824 NULL);
1da177e4
LT
825 if (cifs_sm_req_cachep == NULL) {
826 mempool_destroy(cifs_req_poolp);
827 kmem_cache_destroy(cifs_req_cachep);
6dc0f87e 828 return -ENOMEM;
1da177e4
LT
829 }
830
4523cc30 831 if (cifs_min_small < 2)
1da177e4
LT
832 cifs_min_small = 2;
833 else if (cifs_min_small > 256) {
834 cifs_min_small = 256;
b6b38f70 835 cFYI(1, "cifs_min_small set to maximum (256)");
1da177e4
LT
836 }
837
93d2341c
MD
838 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
839 cifs_sm_req_cachep);
1da177e4 840
4523cc30 841 if (cifs_sm_req_poolp == NULL) {
1da177e4
LT
842 mempool_destroy(cifs_req_poolp);
843 kmem_cache_destroy(cifs_req_cachep);
844 kmem_cache_destroy(cifs_sm_req_cachep);
845 return -ENOMEM;
846 }
847
848 return 0;
849}
850
851static void
852cifs_destroy_request_bufs(void)
853{
854 mempool_destroy(cifs_req_poolp);
1a1d92c1 855 kmem_cache_destroy(cifs_req_cachep);
1da177e4 856 mempool_destroy(cifs_sm_req_poolp);
1a1d92c1 857 kmem_cache_destroy(cifs_sm_req_cachep);
1da177e4
LT
858}
859
860static int
861cifs_init_mids(void)
862{
863 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
26f57364
SF
864 sizeof(struct mid_q_entry), 0,
865 SLAB_HWCACHE_ALIGN, NULL);
1da177e4
LT
866 if (cifs_mid_cachep == NULL)
867 return -ENOMEM;
868
93d2341c
MD
869 /* 3 is a reasonable minimum number of simultaneous operations */
870 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
4523cc30 871 if (cifs_mid_poolp == NULL) {
1da177e4
LT
872 kmem_cache_destroy(cifs_mid_cachep);
873 return -ENOMEM;
874 }
875
1da177e4
LT
876 return 0;
877}
878
879static void
880cifs_destroy_mids(void)
881{
882 mempool_destroy(cifs_mid_poolp);
1a1d92c1 883 kmem_cache_destroy(cifs_mid_cachep);
1da177e4
LT
884}
885
1da177e4
LT
886static int __init
887init_cifs(void)
888{
889 int rc = 0;
1da177e4 890 cifs_proc_init();
e7ddee90 891 INIT_LIST_HEAD(&cifs_tcp_ses_list);
4ca9c190
SF
892#ifdef CONFIG_CIFS_EXPERIMENTAL
893 INIT_LIST_HEAD(&GlobalDnotifyReqList);
894 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
6dc0f87e 895#endif
1da177e4
LT
896/*
897 * Initialize Global counters
898 */
899 atomic_set(&sesInfoAllocCount, 0);
900 atomic_set(&tconInfoAllocCount, 0);
6dc0f87e 901 atomic_set(&tcpSesAllocCount, 0);
1da177e4
LT
902 atomic_set(&tcpSesReconnectCount, 0);
903 atomic_set(&tconInfoReconnectCount, 0);
904
905 atomic_set(&bufAllocCount, 0);
4498eed5
SF
906 atomic_set(&smBufAllocCount, 0);
907#ifdef CONFIG_CIFS_STATS2
908 atomic_set(&totBufAllocCount, 0);
909 atomic_set(&totSmBufAllocCount, 0);
910#endif /* CONFIG_CIFS_STATS2 */
911
1da177e4
LT
912 atomic_set(&midCount, 0);
913 GlobalCurrentXid = 0;
914 GlobalTotalActiveXid = 0;
915 GlobalMaxActiveXid = 0;
2cd646a2 916 memset(Local_System_Name, 0, 15);
1da177e4 917 rwlock_init(&GlobalSMBSeslock);
e7ddee90 918 rwlock_init(&cifs_tcp_ses_lock);
1da177e4
LT
919 spin_lock_init(&GlobalMid_Lock);
920
4523cc30 921 if (cifs_max_pending < 2) {
1da177e4 922 cifs_max_pending = 2;
b6b38f70 923 cFYI(1, "cifs_max_pending set to min of 2");
4523cc30 924 } else if (cifs_max_pending > 256) {
1da177e4 925 cifs_max_pending = 256;
b6b38f70 926 cFYI(1, "cifs_max_pending set to max of 256");
1da177e4
LT
927 }
928
f579cf3c
SJ
929 rc = cifs_fscache_register();
930 if (rc)
d3bf5221 931 goto out_clean_proc;
f579cf3c 932
1da177e4 933 rc = cifs_init_inodecache();
45af7a0f 934 if (rc)
d3bf5221 935 goto out_unreg_fscache;
45af7a0f
SF
936
937 rc = cifs_init_mids();
938 if (rc)
939 goto out_destroy_inodecache;
940
941 rc = cifs_init_request_bufs();
942 if (rc)
943 goto out_destroy_mids;
944
945 rc = register_filesystem(&cifs_fs_type);
946 if (rc)
947 goto out_destroy_request_bufs;
84a15b93
JL
948#ifdef CONFIG_CIFS_UPCALL
949 rc = register_key_type(&cifs_spnego_key_type);
950 if (rc)
951 goto out_unregister_filesystem;
6103335d 952#endif
45af7a0f 953
45af7a0f
SF
954 return 0;
955
84a15b93 956#ifdef CONFIG_CIFS_UPCALL
d3bf5221 957out_unregister_filesystem:
45af7a0f 958 unregister_filesystem(&cifs_fs_type);
1fc7995d 959#endif
d3bf5221 960out_destroy_request_bufs:
45af7a0f 961 cifs_destroy_request_bufs();
d3bf5221 962out_destroy_mids:
45af7a0f 963 cifs_destroy_mids();
d3bf5221 964out_destroy_inodecache:
45af7a0f 965 cifs_destroy_inodecache();
d3bf5221 966out_unreg_fscache:
f579cf3c 967 cifs_fscache_unregister();
d3bf5221
SF
968out_clean_proc:
969 cifs_proc_clean();
1da177e4
LT
970 return rc;
971}
972
973static void __exit
974exit_cifs(void)
975{
b6b38f70 976 cFYI(DBG2, "exit_cifs");
1da177e4 977 cifs_proc_clean();
f579cf3c 978 cifs_fscache_unregister();
6103335d 979#ifdef CONFIG_CIFS_DFS_UPCALL
78d31a3a 980 cifs_dfs_release_automount_timer();
6103335d 981#endif
84a15b93
JL
982#ifdef CONFIG_CIFS_UPCALL
983 unregister_key_type(&cifs_spnego_key_type);
1da177e4
LT
984#endif
985 unregister_filesystem(&cifs_fs_type);
986 cifs_destroy_inodecache();
987 cifs_destroy_mids();
988 cifs_destroy_request_bufs();
1da177e4
LT
989}
990
991MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
6dc0f87e 992MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1da177e4 993MODULE_DESCRIPTION
63135e08
SF
994 ("VFS to access servers complying with the SNIA CIFS Specification "
995 "e.g. Samba and Windows");
1da177e4
LT
996MODULE_VERSION(CIFS_VERSION);
997module_init(init_cifs)
998module_exit(exit_cifs)