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