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