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