Loading...
Note: File does not exist in v6.13.7.
1/*
2 * fs/cifs/cifsfs.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2008
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>
35#include <linux/delay.h>
36#include <linux/kthread.h>
37#include <linux/freezer.h>
38#include <linux/namei.h>
39#include <net/ipv6.h>
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>
48#include <linux/key-type.h>
49#include "cifs_spnego.h"
50#include "fscache.h"
51#define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
52
53int cifsFYI = 0;
54int cifsERROR = 1;
55int traceSMB = 0;
56unsigned int oplockEnabled = 1;
57unsigned int linuxExtEnabled = 1;
58unsigned int lookupCacheEnabled = 1;
59unsigned int multiuser_mount = 0;
60unsigned int global_secflags = CIFSSEC_DEF;
61/* unsigned int ntlmv2_support = 0; */
62unsigned int sign_CIFS_PDUs = 1;
63static const struct super_operations cifs_super_ops;
64unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
65module_param(CIFSMaxBufSize, int, 0);
66MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
67 "Default: 16384 Range: 8192 to 130048");
68unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
69module_param(cifs_min_rcv, int, 0);
70MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
71 "1 to 64");
72unsigned int cifs_min_small = 30;
73module_param(cifs_min_small, int, 0);
74MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
75 "Range: 2 to 256");
76unsigned int cifs_max_pending = CIFS_MAX_REQ;
77module_param(cifs_max_pending, int, 0);
78MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
79 "Default: 50 Range: 2 to 256");
80unsigned short echo_retries = 5;
81module_param(echo_retries, ushort, 0644);
82MODULE_PARM_DESC(echo_retries, "Number of echo attempts before giving up and "
83 "reconnecting server. Default: 5. 0 means "
84 "never reconnect.");
85extern mempool_t *cifs_sm_req_poolp;
86extern mempool_t *cifs_req_poolp;
87extern mempool_t *cifs_mid_poolp;
88
89static int
90cifs_read_super(struct super_block *sb)
91{
92 struct inode *inode;
93 struct cifs_sb_info *cifs_sb;
94 int rc = 0;
95
96 cifs_sb = CIFS_SB(sb);
97
98 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
99 sb->s_flags |= MS_POSIXACL;
100
101 if (cifs_sb_master_tcon(cifs_sb)->ses->capabilities & CAP_LARGE_FILES)
102 sb->s_maxbytes = MAX_LFS_FILESIZE;
103 else
104 sb->s_maxbytes = MAX_NON_LFS;
105
106 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
107 sb->s_time_gran = 100;
108
109 sb->s_magic = CIFS_MAGIC_NUMBER;
110 sb->s_op = &cifs_super_ops;
111 sb->s_bdi = &cifs_sb->bdi;
112 sb->s_blocksize = CIFS_MAX_MSGSIZE;
113 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
114 inode = cifs_root_iget(sb);
115
116 if (IS_ERR(inode)) {
117 rc = PTR_ERR(inode);
118 inode = NULL;
119 goto out_no_root;
120 }
121
122 sb->s_root = d_alloc_root(inode);
123
124 if (!sb->s_root) {
125 rc = -ENOMEM;
126 goto out_no_root;
127 }
128
129 /* do that *after* d_alloc_root() - we want NULL ->d_op for root here */
130 if (cifs_sb_master_tcon(cifs_sb)->nocase)
131 sb->s_d_op = &cifs_ci_dentry_ops;
132 else
133 sb->s_d_op = &cifs_dentry_ops;
134
135#ifdef CIFS_NFSD_EXPORT
136 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
137 cFYI(1, "export ops supported");
138 sb->s_export_op = &cifs_export_ops;
139 }
140#endif /* CIFS_NFSD_EXPORT */
141
142 return 0;
143
144out_no_root:
145 cERROR(1, "cifs_read_super: get root inode failed");
146 if (inode)
147 iput(inode);
148
149 return rc;
150}
151
152static void cifs_kill_sb(struct super_block *sb)
153{
154 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
155 kill_anon_super(sb);
156 cifs_umount(cifs_sb);
157}
158
159static int
160cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
161{
162 struct super_block *sb = dentry->d_sb;
163 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
164 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
165 int rc = -EOPNOTSUPP;
166 int xid;
167
168 xid = GetXid();
169
170 buf->f_type = CIFS_MAGIC_NUMBER;
171
172 /*
173 * PATH_MAX may be too long - it would presumably be total path,
174 * but note that some servers (includinng Samba 3) have a shorter
175 * maximum path.
176 *
177 * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
178 */
179 buf->f_namelen = PATH_MAX;
180 buf->f_files = 0; /* undefined */
181 buf->f_ffree = 0; /* unlimited */
182
183 /*
184 * We could add a second check for a QFS Unix capability bit
185 */
186 if ((tcon->ses->capabilities & CAP_UNIX) &&
187 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
188 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
189
190 /*
191 * Only need to call the old QFSInfo if failed on newer one,
192 * e.g. by OS/2.
193 **/
194 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
195 rc = CIFSSMBQFSInfo(xid, tcon, buf);
196
197 /*
198 * Some old Windows servers also do not support level 103, retry with
199 * older level one if old server failed the previous call or we
200 * bypassed it because we detected that this was an older LANMAN sess
201 */
202 if (rc)
203 rc = SMBOldQFSInfo(xid, tcon, buf);
204
205 FreeXid(xid);
206 return 0;
207}
208
209static int cifs_permission(struct inode *inode, int mask)
210{
211 struct cifs_sb_info *cifs_sb;
212
213 cifs_sb = CIFS_SB(inode->i_sb);
214
215 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
216 if ((mask & MAY_EXEC) && !execute_ok(inode))
217 return -EACCES;
218 else
219 return 0;
220 } else /* file mode might have been restricted at mount time
221 on the client (above and beyond ACL on servers) for
222 servers which do not support setting and viewing mode bits,
223 so allowing client to check permissions is useful */
224 return generic_permission(inode, mask);
225}
226
227static struct kmem_cache *cifs_inode_cachep;
228static struct kmem_cache *cifs_req_cachep;
229static struct kmem_cache *cifs_mid_cachep;
230static struct kmem_cache *cifs_sm_req_cachep;
231mempool_t *cifs_sm_req_poolp;
232mempool_t *cifs_req_poolp;
233mempool_t *cifs_mid_poolp;
234
235static struct inode *
236cifs_alloc_inode(struct super_block *sb)
237{
238 struct cifsInodeInfo *cifs_inode;
239 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
240 if (!cifs_inode)
241 return NULL;
242 cifs_inode->cifsAttrs = 0x20; /* default */
243 cifs_inode->time = 0;
244 /* Until the file is open and we have gotten oplock
245 info back from the server, can not assume caching of
246 file data or metadata */
247 cifs_set_oplock_level(cifs_inode, 0);
248 cifs_inode->delete_pending = false;
249 cifs_inode->invalid_mapping = false;
250 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
251 cifs_inode->server_eof = 0;
252 cifs_inode->uniqueid = 0;
253 cifs_inode->createtime = 0;
254
255 /* Can not set i_flags here - they get immediately overwritten
256 to zero by the VFS */
257/* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
258 INIT_LIST_HEAD(&cifs_inode->openFileList);
259 return &cifs_inode->vfs_inode;
260}
261
262static void cifs_i_callback(struct rcu_head *head)
263{
264 struct inode *inode = container_of(head, struct inode, i_rcu);
265 INIT_LIST_HEAD(&inode->i_dentry);
266 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
267}
268
269static void
270cifs_destroy_inode(struct inode *inode)
271{
272 call_rcu(&inode->i_rcu, cifs_i_callback);
273}
274
275static void
276cifs_evict_inode(struct inode *inode)
277{
278 truncate_inode_pages(&inode->i_data, 0);
279 end_writeback(inode);
280 cifs_fscache_release_inode_cookie(inode);
281}
282
283static void
284cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
285{
286 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
287 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
288
289 seq_printf(s, ",addr=");
290
291 switch (server->dstaddr.ss_family) {
292 case AF_INET:
293 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
294 break;
295 case AF_INET6:
296 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
297 if (sa6->sin6_scope_id)
298 seq_printf(s, "%%%u", sa6->sin6_scope_id);
299 break;
300 default:
301 seq_printf(s, "(unknown)");
302 }
303}
304
305static void
306cifs_show_security(struct seq_file *s, struct TCP_Server_Info *server)
307{
308 seq_printf(s, ",sec=");
309
310 switch (server->secType) {
311 case LANMAN:
312 seq_printf(s, "lanman");
313 break;
314 case NTLMv2:
315 seq_printf(s, "ntlmv2");
316 break;
317 case NTLM:
318 seq_printf(s, "ntlm");
319 break;
320 case Kerberos:
321 seq_printf(s, "krb5");
322 break;
323 case RawNTLMSSP:
324 seq_printf(s, "ntlmssp");
325 break;
326 default:
327 /* shouldn't ever happen */
328 seq_printf(s, "unknown");
329 break;
330 }
331
332 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
333 seq_printf(s, "i");
334}
335
336/*
337 * cifs_show_options() is for displaying mount options in /proc/mounts.
338 * Not all settable options are displayed but most of the important
339 * ones are.
340 */
341static int
342cifs_show_options(struct seq_file *s, struct vfsmount *m)
343{
344 struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
345 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
346 struct sockaddr *srcaddr;
347 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
348
349 cifs_show_security(s, tcon->ses->server);
350
351 seq_printf(s, ",unc=%s", tcon->treeName);
352
353 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
354 seq_printf(s, ",multiuser");
355 else if (tcon->ses->user_name)
356 seq_printf(s, ",username=%s", tcon->ses->user_name);
357
358 if (tcon->ses->domainName)
359 seq_printf(s, ",domain=%s", tcon->ses->domainName);
360
361 if (srcaddr->sa_family != AF_UNSPEC) {
362 struct sockaddr_in *saddr4;
363 struct sockaddr_in6 *saddr6;
364 saddr4 = (struct sockaddr_in *)srcaddr;
365 saddr6 = (struct sockaddr_in6 *)srcaddr;
366 if (srcaddr->sa_family == AF_INET6)
367 seq_printf(s, ",srcaddr=%pI6c",
368 &saddr6->sin6_addr);
369 else if (srcaddr->sa_family == AF_INET)
370 seq_printf(s, ",srcaddr=%pI4",
371 &saddr4->sin_addr.s_addr);
372 else
373 seq_printf(s, ",srcaddr=BAD-AF:%i",
374 (int)(srcaddr->sa_family));
375 }
376
377 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
378 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
379 seq_printf(s, ",forceuid");
380 else
381 seq_printf(s, ",noforceuid");
382
383 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
384 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
385 seq_printf(s, ",forcegid");
386 else
387 seq_printf(s, ",noforcegid");
388
389 cifs_show_address(s, tcon->ses->server);
390
391 if (!tcon->unix_ext)
392 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
393 cifs_sb->mnt_file_mode,
394 cifs_sb->mnt_dir_mode);
395 if (tcon->seal)
396 seq_printf(s, ",seal");
397 if (tcon->nocase)
398 seq_printf(s, ",nocase");
399 if (tcon->retry)
400 seq_printf(s, ",hard");
401 if (tcon->unix_ext)
402 seq_printf(s, ",unix");
403 else
404 seq_printf(s, ",nounix");
405 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
406 seq_printf(s, ",posixpaths");
407 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
408 seq_printf(s, ",setuids");
409 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
410 seq_printf(s, ",serverino");
411 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
412 seq_printf(s, ",rwpidforward");
413 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
414 seq_printf(s, ",forcemand");
415 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
416 seq_printf(s, ",directio");
417 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
418 seq_printf(s, ",nouser_xattr");
419 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
420 seq_printf(s, ",mapchars");
421 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
422 seq_printf(s, ",sfu");
423 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
424 seq_printf(s, ",nobrl");
425 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
426 seq_printf(s, ",cifsacl");
427 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
428 seq_printf(s, ",dynperm");
429 if (m->mnt_sb->s_flags & MS_POSIXACL)
430 seq_printf(s, ",acl");
431 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
432 seq_printf(s, ",mfsymlinks");
433 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
434 seq_printf(s, ",fsc");
435
436 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
437 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
438 /* convert actimeo and display it in seconds */
439 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
440
441 return 0;
442}
443
444static void cifs_umount_begin(struct super_block *sb)
445{
446 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
447 struct cifs_tcon *tcon;
448
449 if (cifs_sb == NULL)
450 return;
451
452 tcon = cifs_sb_master_tcon(cifs_sb);
453
454 spin_lock(&cifs_tcp_ses_lock);
455 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
456 /* we have other mounts to same share or we have
457 already tried to force umount this and woken up
458 all waiting network requests, nothing to do */
459 spin_unlock(&cifs_tcp_ses_lock);
460 return;
461 } else if (tcon->tc_count == 1)
462 tcon->tidStatus = CifsExiting;
463 spin_unlock(&cifs_tcp_ses_lock);
464
465 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
466 /* cancel_notify_requests(tcon); */
467 if (tcon->ses && tcon->ses->server) {
468 cFYI(1, "wake up tasks now - umount begin not complete");
469 wake_up_all(&tcon->ses->server->request_q);
470 wake_up_all(&tcon->ses->server->response_q);
471 msleep(1); /* yield */
472 /* we have to kick the requests once more */
473 wake_up_all(&tcon->ses->server->response_q);
474 msleep(1);
475 }
476
477 return;
478}
479
480#ifdef CONFIG_CIFS_STATS2
481static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
482{
483 /* BB FIXME */
484 return 0;
485}
486#endif
487
488static int cifs_remount(struct super_block *sb, int *flags, char *data)
489{
490 *flags |= MS_NODIRATIME;
491 return 0;
492}
493
494static int cifs_drop_inode(struct inode *inode)
495{
496 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
497
498 /* no serverino => unconditional eviction */
499 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
500 generic_drop_inode(inode);
501}
502
503static const struct super_operations cifs_super_ops = {
504 .statfs = cifs_statfs,
505 .alloc_inode = cifs_alloc_inode,
506 .destroy_inode = cifs_destroy_inode,
507 .drop_inode = cifs_drop_inode,
508 .evict_inode = cifs_evict_inode,
509/* .delete_inode = cifs_delete_inode, */ /* Do not need above
510 function unless later we add lazy close of inodes or unless the
511 kernel forgets to call us with the same number of releases (closes)
512 as opens */
513 .show_options = cifs_show_options,
514 .umount_begin = cifs_umount_begin,
515 .remount_fs = cifs_remount,
516#ifdef CONFIG_CIFS_STATS2
517 .show_stats = cifs_show_stats,
518#endif
519};
520
521/*
522 * Get root dentry from superblock according to prefix path mount option.
523 * Return dentry with refcount + 1 on success and NULL otherwise.
524 */
525static struct dentry *
526cifs_get_root(struct smb_vol *vol, struct super_block *sb)
527{
528 struct dentry *dentry;
529 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
530 char *full_path = NULL;
531 char *s, *p;
532 char sep;
533 int xid;
534
535 full_path = cifs_build_path_to_root(vol, cifs_sb,
536 cifs_sb_master_tcon(cifs_sb));
537 if (full_path == NULL)
538 return ERR_PTR(-ENOMEM);
539
540 cFYI(1, "Get root dentry for %s", full_path);
541
542 xid = GetXid();
543 sep = CIFS_DIR_SEP(cifs_sb);
544 dentry = dget(sb->s_root);
545 p = s = full_path;
546
547 do {
548 struct inode *dir = dentry->d_inode;
549 struct dentry *child;
550
551 if (!dir) {
552 dput(dentry);
553 dentry = ERR_PTR(-ENOENT);
554 break;
555 }
556
557 /* skip separators */
558 while (*s == sep)
559 s++;
560 if (!*s)
561 break;
562 p = s++;
563 /* next separator */
564 while (*s && *s != sep)
565 s++;
566
567 mutex_lock(&dir->i_mutex);
568 child = lookup_one_len(p, dentry, s - p);
569 mutex_unlock(&dir->i_mutex);
570 dput(dentry);
571 dentry = child;
572 } while (!IS_ERR(dentry));
573 _FreeXid(xid);
574 kfree(full_path);
575 return dentry;
576}
577
578static int cifs_set_super(struct super_block *sb, void *data)
579{
580 struct cifs_mnt_data *mnt_data = data;
581 sb->s_fs_info = mnt_data->cifs_sb;
582 return set_anon_super(sb, NULL);
583}
584
585static struct dentry *
586cifs_do_mount(struct file_system_type *fs_type,
587 int flags, const char *dev_name, void *data)
588{
589 int rc;
590 struct super_block *sb;
591 struct cifs_sb_info *cifs_sb;
592 struct smb_vol *volume_info;
593 struct cifs_mnt_data mnt_data;
594 struct dentry *root;
595
596 cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
597
598 volume_info = cifs_get_volume_info((char *)data, dev_name);
599 if (IS_ERR(volume_info))
600 return ERR_CAST(volume_info);
601
602 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
603 if (cifs_sb == NULL) {
604 root = ERR_PTR(-ENOMEM);
605 goto out_nls;
606 }
607
608 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
609 if (cifs_sb->mountdata == NULL) {
610 root = ERR_PTR(-ENOMEM);
611 goto out_cifs_sb;
612 }
613
614 cifs_setup_cifs_sb(volume_info, cifs_sb);
615
616 rc = cifs_mount(cifs_sb, volume_info);
617 if (rc) {
618 if (!(flags & MS_SILENT))
619 cERROR(1, "cifs_mount failed w/return code = %d", rc);
620 root = ERR_PTR(rc);
621 goto out_mountdata;
622 }
623
624 mnt_data.vol = volume_info;
625 mnt_data.cifs_sb = cifs_sb;
626 mnt_data.flags = flags;
627
628 sb = sget(fs_type, cifs_match_super, cifs_set_super, &mnt_data);
629 if (IS_ERR(sb)) {
630 root = ERR_CAST(sb);
631 cifs_umount(cifs_sb);
632 goto out;
633 }
634
635 if (sb->s_root) {
636 cFYI(1, "Use existing superblock");
637 cifs_umount(cifs_sb);
638 } else {
639 sb->s_flags = flags;
640 /* BB should we make this contingent on mount parm? */
641 sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
642
643 rc = cifs_read_super(sb);
644 if (rc) {
645 root = ERR_PTR(rc);
646 goto out_super;
647 }
648
649 sb->s_flags |= MS_ACTIVE;
650 }
651
652 root = cifs_get_root(volume_info, sb);
653 if (IS_ERR(root))
654 goto out_super;
655
656 cFYI(1, "dentry root is: %p", root);
657 goto out;
658
659out_super:
660 deactivate_locked_super(sb);
661out:
662 cifs_cleanup_volume_info(volume_info);
663 return root;
664
665out_mountdata:
666 kfree(cifs_sb->mountdata);
667out_cifs_sb:
668 kfree(cifs_sb);
669out_nls:
670 unload_nls(volume_info->local_nls);
671 goto out;
672}
673
674static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
675 unsigned long nr_segs, loff_t pos)
676{
677 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
678 ssize_t written;
679 int rc;
680
681 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
682
683 if (CIFS_I(inode)->clientCanCacheAll)
684 return written;
685
686 rc = filemap_fdatawrite(inode->i_mapping);
687 if (rc)
688 cFYI(1, "cifs_file_aio_write: %d rc on %p inode", rc, inode);
689
690 return written;
691}
692
693static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
694{
695 /*
696 * origin == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
697 * the cached file length
698 */
699 if (origin != SEEK_SET || origin != SEEK_CUR) {
700 int rc;
701 struct inode *inode = file->f_path.dentry->d_inode;
702
703 /*
704 * We need to be sure that all dirty pages are written and the
705 * server has the newest file length.
706 */
707 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
708 inode->i_mapping->nrpages != 0) {
709 rc = filemap_fdatawait(inode->i_mapping);
710 if (rc) {
711 mapping_set_error(inode->i_mapping, rc);
712 return rc;
713 }
714 }
715 /*
716 * Some applications poll for the file length in this strange
717 * way so we must seek to end on non-oplocked files by
718 * setting the revalidate time to zero.
719 */
720 CIFS_I(inode)->time = 0;
721
722 rc = cifs_revalidate_file_attr(file);
723 if (rc < 0)
724 return (loff_t)rc;
725 }
726 return generic_file_llseek_unlocked(file, offset, origin);
727}
728
729static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
730{
731 /* note that this is called by vfs setlease with lock_flocks held
732 to protect *lease from going away */
733 struct inode *inode = file->f_path.dentry->d_inode;
734 struct cifsFileInfo *cfile = file->private_data;
735
736 if (!(S_ISREG(inode->i_mode)))
737 return -EINVAL;
738
739 /* check if file is oplocked */
740 if (((arg == F_RDLCK) &&
741 (CIFS_I(inode)->clientCanCacheRead)) ||
742 ((arg == F_WRLCK) &&
743 (CIFS_I(inode)->clientCanCacheAll)))
744 return generic_setlease(file, arg, lease);
745 else if (tlink_tcon(cfile->tlink)->local_lease &&
746 !CIFS_I(inode)->clientCanCacheRead)
747 /* If the server claims to support oplock on this
748 file, then we still need to check oplock even
749 if the local_lease mount option is set, but there
750 are servers which do not support oplock for which
751 this mount option may be useful if the user
752 knows that the file won't be changed on the server
753 by anyone else */
754 return generic_setlease(file, arg, lease);
755 else
756 return -EAGAIN;
757}
758
759struct file_system_type cifs_fs_type = {
760 .owner = THIS_MODULE,
761 .name = "cifs",
762 .mount = cifs_do_mount,
763 .kill_sb = cifs_kill_sb,
764 /* .fs_flags */
765};
766const struct inode_operations cifs_dir_inode_ops = {
767 .create = cifs_create,
768 .lookup = cifs_lookup,
769 .getattr = cifs_getattr,
770 .unlink = cifs_unlink,
771 .link = cifs_hardlink,
772 .mkdir = cifs_mkdir,
773 .rmdir = cifs_rmdir,
774 .rename = cifs_rename,
775 .permission = cifs_permission,
776/* revalidate:cifs_revalidate, */
777 .setattr = cifs_setattr,
778 .symlink = cifs_symlink,
779 .mknod = cifs_mknod,
780#ifdef CONFIG_CIFS_XATTR
781 .setxattr = cifs_setxattr,
782 .getxattr = cifs_getxattr,
783 .listxattr = cifs_listxattr,
784 .removexattr = cifs_removexattr,
785#endif
786};
787
788const struct inode_operations cifs_file_inode_ops = {
789/* revalidate:cifs_revalidate, */
790 .setattr = cifs_setattr,
791 .getattr = cifs_getattr, /* do we need this anymore? */
792 .rename = cifs_rename,
793 .permission = cifs_permission,
794#ifdef CONFIG_CIFS_XATTR
795 .setxattr = cifs_setxattr,
796 .getxattr = cifs_getxattr,
797 .listxattr = cifs_listxattr,
798 .removexattr = cifs_removexattr,
799#endif
800};
801
802const struct inode_operations cifs_symlink_inode_ops = {
803 .readlink = generic_readlink,
804 .follow_link = cifs_follow_link,
805 .put_link = cifs_put_link,
806 .permission = cifs_permission,
807 /* BB add the following two eventually */
808 /* revalidate: cifs_revalidate,
809 setattr: cifs_notify_change, *//* BB do we need notify change */
810#ifdef CONFIG_CIFS_XATTR
811 .setxattr = cifs_setxattr,
812 .getxattr = cifs_getxattr,
813 .listxattr = cifs_listxattr,
814 .removexattr = cifs_removexattr,
815#endif
816};
817
818const struct file_operations cifs_file_ops = {
819 .read = do_sync_read,
820 .write = do_sync_write,
821 .aio_read = generic_file_aio_read,
822 .aio_write = cifs_file_aio_write,
823 .open = cifs_open,
824 .release = cifs_close,
825 .lock = cifs_lock,
826 .fsync = cifs_fsync,
827 .flush = cifs_flush,
828 .mmap = cifs_file_mmap,
829 .splice_read = generic_file_splice_read,
830 .llseek = cifs_llseek,
831#ifdef CONFIG_CIFS_POSIX
832 .unlocked_ioctl = cifs_ioctl,
833#endif /* CONFIG_CIFS_POSIX */
834 .setlease = cifs_setlease,
835};
836
837const struct file_operations cifs_file_strict_ops = {
838 .read = do_sync_read,
839 .write = do_sync_write,
840 .aio_read = cifs_strict_readv,
841 .aio_write = cifs_strict_writev,
842 .open = cifs_open,
843 .release = cifs_close,
844 .lock = cifs_lock,
845 .fsync = cifs_strict_fsync,
846 .flush = cifs_flush,
847 .mmap = cifs_file_strict_mmap,
848 .splice_read = generic_file_splice_read,
849 .llseek = cifs_llseek,
850#ifdef CONFIG_CIFS_POSIX
851 .unlocked_ioctl = cifs_ioctl,
852#endif /* CONFIG_CIFS_POSIX */
853 .setlease = cifs_setlease,
854};
855
856const struct file_operations cifs_file_direct_ops = {
857 /* BB reevaluate whether they can be done with directio, no cache */
858 .read = do_sync_read,
859 .write = do_sync_write,
860 .aio_read = cifs_user_readv,
861 .aio_write = cifs_user_writev,
862 .open = cifs_open,
863 .release = cifs_close,
864 .lock = cifs_lock,
865 .fsync = cifs_fsync,
866 .flush = cifs_flush,
867 .mmap = cifs_file_mmap,
868 .splice_read = generic_file_splice_read,
869#ifdef CONFIG_CIFS_POSIX
870 .unlocked_ioctl = cifs_ioctl,
871#endif /* CONFIG_CIFS_POSIX */
872 .llseek = cifs_llseek,
873 .setlease = cifs_setlease,
874};
875
876const struct file_operations cifs_file_nobrl_ops = {
877 .read = do_sync_read,
878 .write = do_sync_write,
879 .aio_read = generic_file_aio_read,
880 .aio_write = cifs_file_aio_write,
881 .open = cifs_open,
882 .release = cifs_close,
883 .fsync = cifs_fsync,
884 .flush = cifs_flush,
885 .mmap = cifs_file_mmap,
886 .splice_read = generic_file_splice_read,
887 .llseek = cifs_llseek,
888#ifdef CONFIG_CIFS_POSIX
889 .unlocked_ioctl = cifs_ioctl,
890#endif /* CONFIG_CIFS_POSIX */
891 .setlease = cifs_setlease,
892};
893
894const struct file_operations cifs_file_strict_nobrl_ops = {
895 .read = do_sync_read,
896 .write = do_sync_write,
897 .aio_read = cifs_strict_readv,
898 .aio_write = cifs_strict_writev,
899 .open = cifs_open,
900 .release = cifs_close,
901 .fsync = cifs_strict_fsync,
902 .flush = cifs_flush,
903 .mmap = cifs_file_strict_mmap,
904 .splice_read = generic_file_splice_read,
905 .llseek = cifs_llseek,
906#ifdef CONFIG_CIFS_POSIX
907 .unlocked_ioctl = cifs_ioctl,
908#endif /* CONFIG_CIFS_POSIX */
909 .setlease = cifs_setlease,
910};
911
912const struct file_operations cifs_file_direct_nobrl_ops = {
913 /* BB reevaluate whether they can be done with directio, no cache */
914 .read = do_sync_read,
915 .write = do_sync_write,
916 .aio_read = cifs_user_readv,
917 .aio_write = cifs_user_writev,
918 .open = cifs_open,
919 .release = cifs_close,
920 .fsync = cifs_fsync,
921 .flush = cifs_flush,
922 .mmap = cifs_file_mmap,
923 .splice_read = generic_file_splice_read,
924#ifdef CONFIG_CIFS_POSIX
925 .unlocked_ioctl = cifs_ioctl,
926#endif /* CONFIG_CIFS_POSIX */
927 .llseek = cifs_llseek,
928 .setlease = cifs_setlease,
929};
930
931const struct file_operations cifs_dir_ops = {
932 .readdir = cifs_readdir,
933 .release = cifs_closedir,
934 .read = generic_read_dir,
935 .unlocked_ioctl = cifs_ioctl,
936 .llseek = generic_file_llseek,
937};
938
939static void
940cifs_init_once(void *inode)
941{
942 struct cifsInodeInfo *cifsi = inode;
943
944 inode_init_once(&cifsi->vfs_inode);
945 INIT_LIST_HEAD(&cifsi->lockList);
946}
947
948static int
949cifs_init_inodecache(void)
950{
951 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
952 sizeof(struct cifsInodeInfo),
953 0, (SLAB_RECLAIM_ACCOUNT|
954 SLAB_MEM_SPREAD),
955 cifs_init_once);
956 if (cifs_inode_cachep == NULL)
957 return -ENOMEM;
958
959 return 0;
960}
961
962static void
963cifs_destroy_inodecache(void)
964{
965 kmem_cache_destroy(cifs_inode_cachep);
966}
967
968static int
969cifs_init_request_bufs(void)
970{
971 if (CIFSMaxBufSize < 8192) {
972 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
973 Unicode path name has to fit in any SMB/CIFS path based frames */
974 CIFSMaxBufSize = 8192;
975 } else if (CIFSMaxBufSize > 1024*127) {
976 CIFSMaxBufSize = 1024 * 127;
977 } else {
978 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
979 }
980/* cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
981 cifs_req_cachep = kmem_cache_create("cifs_request",
982 CIFSMaxBufSize +
983 MAX_CIFS_HDR_SIZE, 0,
984 SLAB_HWCACHE_ALIGN, NULL);
985 if (cifs_req_cachep == NULL)
986 return -ENOMEM;
987
988 if (cifs_min_rcv < 1)
989 cifs_min_rcv = 1;
990 else if (cifs_min_rcv > 64) {
991 cifs_min_rcv = 64;
992 cERROR(1, "cifs_min_rcv set to maximum (64)");
993 }
994
995 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
996 cifs_req_cachep);
997
998 if (cifs_req_poolp == NULL) {
999 kmem_cache_destroy(cifs_req_cachep);
1000 return -ENOMEM;
1001 }
1002 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1003 almost all handle based requests (but not write response, nor is it
1004 sufficient for path based requests). A smaller size would have
1005 been more efficient (compacting multiple slab items on one 4k page)
1006 for the case in which debug was on, but this larger size allows
1007 more SMBs to use small buffer alloc and is still much more
1008 efficient to alloc 1 per page off the slab compared to 17K (5page)
1009 alloc of large cifs buffers even when page debugging is on */
1010 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
1011 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1012 NULL);
1013 if (cifs_sm_req_cachep == NULL) {
1014 mempool_destroy(cifs_req_poolp);
1015 kmem_cache_destroy(cifs_req_cachep);
1016 return -ENOMEM;
1017 }
1018
1019 if (cifs_min_small < 2)
1020 cifs_min_small = 2;
1021 else if (cifs_min_small > 256) {
1022 cifs_min_small = 256;
1023 cFYI(1, "cifs_min_small set to maximum (256)");
1024 }
1025
1026 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1027 cifs_sm_req_cachep);
1028
1029 if (cifs_sm_req_poolp == NULL) {
1030 mempool_destroy(cifs_req_poolp);
1031 kmem_cache_destroy(cifs_req_cachep);
1032 kmem_cache_destroy(cifs_sm_req_cachep);
1033 return -ENOMEM;
1034 }
1035
1036 return 0;
1037}
1038
1039static void
1040cifs_destroy_request_bufs(void)
1041{
1042 mempool_destroy(cifs_req_poolp);
1043 kmem_cache_destroy(cifs_req_cachep);
1044 mempool_destroy(cifs_sm_req_poolp);
1045 kmem_cache_destroy(cifs_sm_req_cachep);
1046}
1047
1048static int
1049cifs_init_mids(void)
1050{
1051 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1052 sizeof(struct mid_q_entry), 0,
1053 SLAB_HWCACHE_ALIGN, NULL);
1054 if (cifs_mid_cachep == NULL)
1055 return -ENOMEM;
1056
1057 /* 3 is a reasonable minimum number of simultaneous operations */
1058 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1059 if (cifs_mid_poolp == NULL) {
1060 kmem_cache_destroy(cifs_mid_cachep);
1061 return -ENOMEM;
1062 }
1063
1064 return 0;
1065}
1066
1067static void
1068cifs_destroy_mids(void)
1069{
1070 mempool_destroy(cifs_mid_poolp);
1071 kmem_cache_destroy(cifs_mid_cachep);
1072}
1073
1074static int __init
1075init_cifs(void)
1076{
1077 int rc = 0;
1078 cifs_proc_init();
1079 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1080#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1081 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1082 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1083#endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1084/*
1085 * Initialize Global counters
1086 */
1087 atomic_set(&sesInfoAllocCount, 0);
1088 atomic_set(&tconInfoAllocCount, 0);
1089 atomic_set(&tcpSesAllocCount, 0);
1090 atomic_set(&tcpSesReconnectCount, 0);
1091 atomic_set(&tconInfoReconnectCount, 0);
1092
1093 atomic_set(&bufAllocCount, 0);
1094 atomic_set(&smBufAllocCount, 0);
1095#ifdef CONFIG_CIFS_STATS2
1096 atomic_set(&totBufAllocCount, 0);
1097 atomic_set(&totSmBufAllocCount, 0);
1098#endif /* CONFIG_CIFS_STATS2 */
1099
1100 atomic_set(&midCount, 0);
1101 GlobalCurrentXid = 0;
1102 GlobalTotalActiveXid = 0;
1103 GlobalMaxActiveXid = 0;
1104 spin_lock_init(&cifs_tcp_ses_lock);
1105 spin_lock_init(&cifs_file_list_lock);
1106 spin_lock_init(&GlobalMid_Lock);
1107
1108 if (cifs_max_pending < 2) {
1109 cifs_max_pending = 2;
1110 cFYI(1, "cifs_max_pending set to min of 2");
1111 } else if (cifs_max_pending > 256) {
1112 cifs_max_pending = 256;
1113 cFYI(1, "cifs_max_pending set to max of 256");
1114 }
1115
1116 rc = cifs_fscache_register();
1117 if (rc)
1118 goto out_clean_proc;
1119
1120 rc = cifs_init_inodecache();
1121 if (rc)
1122 goto out_unreg_fscache;
1123
1124 rc = cifs_init_mids();
1125 if (rc)
1126 goto out_destroy_inodecache;
1127
1128 rc = cifs_init_request_bufs();
1129 if (rc)
1130 goto out_destroy_mids;
1131
1132#ifdef CONFIG_CIFS_UPCALL
1133 rc = register_key_type(&cifs_spnego_key_type);
1134 if (rc)
1135 goto out_destroy_request_bufs;
1136#endif /* CONFIG_CIFS_UPCALL */
1137
1138#ifdef CONFIG_CIFS_ACL
1139 rc = init_cifs_idmap();
1140 if (rc)
1141 goto out_register_key_type;
1142#endif /* CONFIG_CIFS_ACL */
1143
1144 rc = register_filesystem(&cifs_fs_type);
1145 if (rc)
1146 goto out_init_cifs_idmap;
1147
1148 return 0;
1149
1150out_init_cifs_idmap:
1151#ifdef CONFIG_CIFS_ACL
1152 exit_cifs_idmap();
1153out_register_key_type:
1154#endif
1155#ifdef CONFIG_CIFS_UPCALL
1156 unregister_key_type(&cifs_spnego_key_type);
1157out_destroy_request_bufs:
1158#endif
1159 cifs_destroy_request_bufs();
1160out_destroy_mids:
1161 cifs_destroy_mids();
1162out_destroy_inodecache:
1163 cifs_destroy_inodecache();
1164out_unreg_fscache:
1165 cifs_fscache_unregister();
1166out_clean_proc:
1167 cifs_proc_clean();
1168 return rc;
1169}
1170
1171static void __exit
1172exit_cifs(void)
1173{
1174 cFYI(DBG2, "exit_cifs");
1175 cifs_proc_clean();
1176 cifs_fscache_unregister();
1177#ifdef CONFIG_CIFS_DFS_UPCALL
1178 cifs_dfs_release_automount_timer();
1179#endif
1180#ifdef CONFIG_CIFS_ACL
1181 cifs_destroy_idmaptrees();
1182 exit_cifs_idmap();
1183#endif
1184#ifdef CONFIG_CIFS_UPCALL
1185 unregister_key_type(&cifs_spnego_key_type);
1186#endif
1187 unregister_filesystem(&cifs_fs_type);
1188 cifs_destroy_inodecache();
1189 cifs_destroy_mids();
1190 cifs_destroy_request_bufs();
1191}
1192
1193MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1194MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1195MODULE_DESCRIPTION
1196 ("VFS to access servers complying with the SNIA CIFS Specification "
1197 "e.g. Samba and Windows");
1198MODULE_VERSION(CIFS_VERSION);
1199module_init(init_cifs)
1200module_exit(exit_cifs)