projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
NFS: Fix Oopsable condition in nfs_readpage_sync()
[linux-2.6-block.git] / fs / ncpfs / inode.c
CommitLineData
1da177e4
LT		 1/*
2 * inode.c
3 *
4 * Copyright (C) 1995, 1996 by Volker Lendecke
5 * Modified for big endian by J.F. Chadima and David S. Miller
6 * Modified 1997 Peter Waltenberg, Bill Hawes, David Woodhouse for 2.1 dcache
7 * Modified 1998 Wolfram Pienkoss for NLS
8 * Modified 2000 Ben Harris, University of Cambridge for NFS NS meta-info
9 *
10 */
11
1da177e4
LT		 12#include <linux/module.h>
13
14#include <asm/system.h>
15#include <asm/uaccess.h>
16#include <asm/byteorder.h>
17
18#include <linux/time.h>
19#include <linux/kernel.h>
20#include <linux/mm.h>
21#include <linux/string.h>
22#include <linux/stat.h>
23#include <linux/errno.h>
24#include <linux/file.h>
25#include <linux/fcntl.h>
26#include <linux/slab.h>
27#include <linux/vmalloc.h>
28#include <linux/init.h>
29#include <linux/smp_lock.h>
30#include <linux/vfs.h>
31
32#include <linux/ncp_fs.h>
33
34#include <net/sock.h>
35
36#include "ncplib_kernel.h"
37#include "getopt.h"
38
39static void ncp_delete_inode(struct inode *);
40static void ncp_put_super(struct super_block *);
726c3342 41static int ncp_statfs(struct dentry *, struct kstatfs *);
1da177e4
LT		 42
43static kmem_cache_t * ncp_inode_cachep;
44
45static struct inode *ncp_alloc_inode(struct super_block *sb)
46{
47 struct ncp_inode_info *ei;
48 ei = (struct ncp_inode_info *)kmem_cache_alloc(ncp_inode_cachep, SLAB_KERNEL);
49 if (!ei)
50 return NULL;
51 return &ei->vfs_inode;
52}
53
54static void ncp_destroy_inode(struct inode *inode)
55{
56 kmem_cache_free(ncp_inode_cachep, NCP_FINFO(inode));
57}
58
59static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
60{
61 struct ncp_inode_info *ei = (struct ncp_inode_info *) foo;
62
63 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
64 SLAB_CTOR_CONSTRUCTOR) {
8e3f9045 65 mutex_init(&ei->open_mutex);
1da177e4
LT		 66 inode_init_once(&ei->vfs_inode);
67 }
68}
69
70static int init_inodecache(void)
71{
72 ncp_inode_cachep = kmem_cache_create("ncp_inode_cache",
73 sizeof(struct ncp_inode_info),
fffb60f9
PJ		 74 0, (SLAB_RECLAIM_ACCOUNT|
75 SLAB_MEM_SPREAD),
1da177e4
LT		 76 init_once, NULL);
77 if (ncp_inode_cachep == NULL)
78 return -ENOMEM;
79 return 0;
80}
81
82static void destroy_inodecache(void)
83{
84 if (kmem_cache_destroy(ncp_inode_cachep))
85 printk(KERN_INFO "ncp_inode_cache: not all structures were freed\n");
86}
87
88static int ncp_remount(struct super_block *sb, int *flags, char* data)
89{
90 *flags |= MS_NODIRATIME;
91 return 0;
92}
93
94static struct super_operations ncp_sops =
95{
96 .alloc_inode = ncp_alloc_inode,
97 .destroy_inode = ncp_destroy_inode,
98 .drop_inode = generic_delete_inode,
99 .delete_inode = ncp_delete_inode,
100 .put_super = ncp_put_super,
101 .statfs = ncp_statfs,
102 .remount_fs = ncp_remount,
103};
104
105extern struct dentry_operations ncp_root_dentry_operations;
106#if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
f5e54d6e 107extern const struct address_space_operations ncp_symlink_aops;
1da177e4
LT		 108extern int ncp_symlink(struct inode*, struct dentry*, const char*);
109#endif
110
111/*
112 * Fill in the ncpfs-specific information in the inode.
113 */
114static void ncp_update_dirent(struct inode *inode, struct ncp_entry_info *nwinfo)
115{
116 NCP_FINFO(inode)->DosDirNum = nwinfo->i.DosDirNum;
117 NCP_FINFO(inode)->dirEntNum = nwinfo->i.dirEntNum;
118 NCP_FINFO(inode)->volNumber = nwinfo->volume;
119}
120
121void ncp_update_inode(struct inode *inode, struct ncp_entry_info *nwinfo)
122{
123 ncp_update_dirent(inode, nwinfo);
124 NCP_FINFO(inode)->nwattr = nwinfo->i.attributes;
125 NCP_FINFO(inode)->access = nwinfo->access;
126 memcpy(NCP_FINFO(inode)->file_handle, nwinfo->file_handle,
127 sizeof(nwinfo->file_handle));
128 DPRINTK("ncp_update_inode: updated %s, volnum=%d, dirent=%u\n",
129 nwinfo->i.entryName, NCP_FINFO(inode)->volNumber,
130 NCP_FINFO(inode)->dirEntNum);
131}
132
133static void ncp_update_dates(struct inode *inode, struct nw_info_struct *nwi)
134{
135 /* NFS namespace mode overrides others if it's set. */
136 DPRINTK(KERN_DEBUG "ncp_update_dates_and_mode: (%s) nfs.mode=0%o\n",
137 nwi->entryName, nwi->nfs.mode);
138 if (nwi->nfs.mode) {
139 /* XXX Security? */
140 inode->i_mode = nwi->nfs.mode;
141 }
142
143 inode->i_blocks = (inode->i_size + NCP_BLOCK_SIZE - 1) >> NCP_BLOCK_SHIFT;
144
145 inode->i_mtime.tv_sec = ncp_date_dos2unix(nwi->modifyTime, nwi->modifyDate);
146 inode->i_ctime.tv_sec = ncp_date_dos2unix(nwi->creationTime, nwi->creationDate);
147 inode->i_atime.tv_sec = ncp_date_dos2unix(0, nwi->lastAccessDate);
148 inode->i_atime.tv_nsec = 0;
149 inode->i_mtime.tv_nsec = 0;
150 inode->i_ctime.tv_nsec = 0;
151}
152
153static void ncp_update_attrs(struct inode *inode, struct ncp_entry_info *nwinfo)
154{
155 struct nw_info_struct *nwi = &nwinfo->i;
156 struct ncp_server *server = NCP_SERVER(inode);
157
158 if (nwi->attributes & aDIR) {
159 inode->i_mode = server->m.dir_mode;
160 /* for directories dataStreamSize seems to be some
161 Object ID ??? */
162 inode->i_size = NCP_BLOCK_SIZE;
163 } else {
164 inode->i_mode = server->m.file_mode;
165 inode->i_size = le32_to_cpu(nwi->dataStreamSize);
166#ifdef CONFIG_NCPFS_EXTRAS
167 if ((server->m.flags & (NCP_MOUNT_EXTRAS|NCP_MOUNT_SYMLINKS))
168 && (nwi->attributes & aSHARED)) {
169 switch (nwi->attributes & (aHIDDEN|aSYSTEM)) {
170 case aHIDDEN:
171 if (server->m.flags & NCP_MOUNT_SYMLINKS) {
172 if (/* (inode->i_size >= NCP_MIN_SYMLINK_SIZE)
173 && */ (inode->i_size <= NCP_MAX_SYMLINK_SIZE)) {
174 inode->i_mode = (inode->i_mode & ~S_IFMT) | S_IFLNK;
175 NCP_FINFO(inode)->flags |= NCPI_KLUDGE_SYMLINK;
176 break;
177 }
178 }
179 /* FALLTHROUGH */
180 case 0:
181 if (server->m.flags & NCP_MOUNT_EXTRAS)
182 inode->i_mode |= S_IRUGO;
183 break;
184 case aSYSTEM:
185 if (server->m.flags & NCP_MOUNT_EXTRAS)
186 inode->i_mode |= (inode->i_mode >> 2) & S_IXUGO;
187 break;
188 /* case aSYSTEM|aHIDDEN: */
189 default:
190 /* reserved combination */
191 break;
192 }
193 }
194#endif
195 }
196 if (nwi->attributes & aRONLY) inode->i_mode &= ~S_IWUGO;
197}
198
199void ncp_update_inode2(struct inode* inode, struct ncp_entry_info *nwinfo)
200{
201 NCP_FINFO(inode)->flags = 0;
202 if (!atomic_read(&NCP_FINFO(inode)->opened)) {
203 NCP_FINFO(inode)->nwattr = nwinfo->i.attributes;
204 ncp_update_attrs(inode, nwinfo);
205 }
206
207 ncp_update_dates(inode, &nwinfo->i);
208 ncp_update_dirent(inode, nwinfo);
209}
210
211/*
212 * Fill in the inode based on the ncp_entry_info structure.
213 */
214static void ncp_set_attr(struct inode *inode, struct ncp_entry_info *nwinfo)
215{
216 struct ncp_server *server = NCP_SERVER(inode);
217
218 NCP_FINFO(inode)->flags = 0;
219
220 ncp_update_attrs(inode, nwinfo);
221
222 DDPRINTK("ncp_read_inode: inode->i_mode = %u\n", inode->i_mode);
223
224 inode->i_nlink = 1;
225 inode->i_uid = server->m.uid;
226 inode->i_gid = server->m.gid;
227 inode->i_blksize = NCP_BLOCK_SIZE;
228
229 ncp_update_dates(inode, &nwinfo->i);
230 ncp_update_inode(inode, nwinfo);
231}
232
233#if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
234static struct inode_operations ncp_symlink_inode_operations = {
235 .readlink = generic_readlink,
236 .follow_link = page_follow_link_light,
237 .put_link = page_put_link,
238 .setattr = ncp_notify_change,
239};
240#endif
241
242/*
243 * Get a new inode.
244 */
245struct inode *
246ncp_iget(struct super_block *sb, struct ncp_entry_info *info)
247{
248 struct inode *inode;
249
250 if (info == NULL) {
251 printk(KERN_ERR "ncp_iget: info is NULL\n");
252 return NULL;
253 }
254
255 inode = new_inode(sb);
256 if (inode) {
257 atomic_set(&NCP_FINFO(inode)->opened, info->opened);
258
259 inode->i_ino = info->ino;
260 ncp_set_attr(inode, info);
261 if (S_ISREG(inode->i_mode)) {
262 inode->i_op = &ncp_file_inode_operations;
263 inode->i_fop = &ncp_file_operations;
264 } else if (S_ISDIR(inode->i_mode)) {
265 inode->i_op = &ncp_dir_inode_operations;
266 inode->i_fop = &ncp_dir_operations;
267#ifdef CONFIG_NCPFS_NFS_NS
268 } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
269 init_special_inode(inode, inode->i_mode,
270 new_decode_dev(info->i.nfs.rdev));
271#endif
272#if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
273 } else if (S_ISLNK(inode->i_mode)) {
274 inode->i_op = &ncp_symlink_inode_operations;
275 inode->i_data.a_ops = &ncp_symlink_aops;
276#endif
277 } else {
278 make_bad_inode(inode);
279 }
280 insert_inode_hash(inode);
281 } else
282 printk(KERN_ERR "ncp_iget: iget failed!\n");
283 return inode;
284}
285
286static void
287ncp_delete_inode(struct inode *inode)
288{
fef26658
MF		 289 truncate_inode_pages(&inode->i_data, 0);
290
1da177e4
LT		 291 if (S_ISDIR(inode->i_mode)) {
292 DDPRINTK("ncp_delete_inode: put directory %ld\n", inode->i_ino);
293 }
294
295 if (ncp_make_closed(inode) != 0) {
296 /* We can't do anything but complain. */
297 printk(KERN_ERR "ncp_delete_inode: could not close\n");
298 }
299 clear_inode(inode);
300}
301
302static void ncp_stop_tasks(struct ncp_server *server) {
303 struct sock* sk = server->ncp_sock->sk;
304
305 sk->sk_error_report = server->error_report;
306 sk->sk_data_ready = server->data_ready;
307 sk->sk_write_space = server->write_space;
308 del_timer_sync(&server->timeout_tm);
309 flush_scheduled_work();
310}
311
312static const struct ncp_option ncp_opts[] = {
313 { "uid", OPT_INT, 'u' },
314 { "gid", OPT_INT, 'g' },
315 { "owner", OPT_INT, 'o' },
316 { "mode", OPT_INT, 'm' },
317 { "dirmode", OPT_INT, 'd' },
318 { "timeout", OPT_INT, 't' },
319 { "retry", OPT_INT, 'r' },
320 { "flags", OPT_INT, 'f' },
321 { "wdogpid", OPT_INT, 'w' },
322 { "ncpfd", OPT_INT, 'n' },
323 { "infofd", OPT_INT, 'i' }, /* v5 */
324 { "version", OPT_INT, 'v' },
325 { NULL, 0, 0 } };
326
327static int ncp_parse_options(struct ncp_mount_data_kernel *data, char *options) {
328 int optval;
329 char *optarg;
330 unsigned long optint;
331 int version = 0;
332
333 data->flags = 0;
334 data->int_flags = 0;
335 data->mounted_uid = 0;
336 data->wdog_pid = -1;
337 data->ncp_fd = ~0;
338 data->time_out = 10;
339 data->retry_count = 20;
340 data->uid = 0;
341 data->gid = 0;
342 data->file_mode = 0600;
343 data->dir_mode = 0700;
344 data->info_fd = -1;
345 data->mounted_vol[0] = 0;
346
347 while ((optval = ncp_getopt("ncpfs", &options, ncp_opts, NULL, &optarg, &optint)) != 0) {
348 if (optval < 0)
349 return optval;
350 switch (optval) {
351 case 'u':
352 data->uid = optint;
353 break;
354 case 'g':
355 data->gid = optint;
356 break;
357 case 'o':
358 data->mounted_uid = optint;
359 break;
360 case 'm':
361 data->file_mode = optint;
362 break;
363 case 'd':
364 data->dir_mode = optint;
365 break;
366 case 't':
367 data->time_out = optint;
368 break;
369 case 'r':
370 data->retry_count = optint;
371 break;
372 case 'f':
373 data->flags = optint;
374 break;
375 case 'w':
376 data->wdog_pid = optint;
377 break;
378 case 'n':
379 data->ncp_fd = optint;
380 break;
381 case 'i':
382 data->info_fd = optint;
383 break;
384 case 'v':
385 if (optint < NCP_MOUNT_VERSION_V4) {
386 return -ECHRNG;
387 }
388 if (optint > NCP_MOUNT_VERSION_V5) {
389 return -ECHRNG;
390 }
391 version = optint;
392 break;
393
394 }
395 }
396 return 0;
397}
398
399static int ncp_fill_super(struct super_block *sb, void *raw_data, int silent)
400{
401 struct ncp_mount_data_kernel data;
402 struct ncp_server *server;
403 struct file *ncp_filp;
404 struct inode *root_inode;
405 struct inode *sock_inode;
406 struct socket *sock;
407 int error;
408 int default_bufsize;
409#ifdef CONFIG_NCPFS_PACKET_SIGNING
410 int options;
411#endif
412 struct ncp_entry_info finfo;
413
414 server = kmalloc(sizeof(struct ncp_server), GFP_KERNEL);
415 if (!server)
416 return -ENOMEM;
417 sb->s_fs_info = server;
418 memset(server, 0, sizeof(struct ncp_server));
419
420 error = -EFAULT;
421 if (raw_data == NULL)
422 goto out;
423 switch (*(int*)raw_data) {
424 case NCP_MOUNT_VERSION:
425 {
426 struct ncp_mount_data* md = (struct ncp_mount_data*)raw_data;
427
428 data.flags = md->flags;
429 data.int_flags = NCP_IMOUNT_LOGGEDIN_POSSIBLE;
430 data.mounted_uid = md->mounted_uid;
431 data.wdog_pid = md->wdog_pid;
432 data.ncp_fd = md->ncp_fd;
433 data.time_out = md->time_out;
434 data.retry_count = md->retry_count;
435 data.uid = md->uid;
436 data.gid = md->gid;
437 data.file_mode = md->file_mode;
438 data.dir_mode = md->dir_mode;
439 data.info_fd = -1;
440 memcpy(data.mounted_vol, md->mounted_vol,
441 NCP_VOLNAME_LEN+1);
442 }
443 break;
444 case NCP_MOUNT_VERSION_V4:
445 {
446 struct ncp_mount_data_v4* md = (struct ncp_mount_data_v4*)raw_data;
447
448 data.flags = md->flags;
449 data.int_flags = 0;
450 data.mounted_uid = md->mounted_uid;
451 data.wdog_pid = md->wdog_pid;
452 data.ncp_fd = md->ncp_fd;
453 data.time_out = md->time_out;
454 data.retry_count = md->retry_count;
455 data.uid = md->uid;
456 data.gid = md->gid;
457 data.file_mode = md->file_mode;
458 data.dir_mode = md->dir_mode;
459 data.info_fd = -1;
460 data.mounted_vol[0] = 0;
461 }
462 break;
463 default:
464 error = -ECHRNG;
465 if (memcmp(raw_data, "vers", 4) == 0) {
466 error = ncp_parse_options(&data, raw_data);
467 }
468 if (error)
469 goto out;
470 break;
471 }
472 error = -EBADF;
473 ncp_filp = fget(data.ncp_fd);
474 if (!ncp_filp)
475 goto out;
476 error = -ENOTSOCK;
477 sock_inode = ncp_filp->f_dentry->d_inode;
478 if (!S_ISSOCK(sock_inode->i_mode))
479 goto out_fput;
480 sock = SOCKET_I(sock_inode);
481 if (!sock)
482 goto out_fput;
483
484 if (sock->type == SOCK_STREAM)
485 default_bufsize = 0xF000;
486 else
487 default_bufsize = 1024;
488
489 sb->s_flags |= MS_NODIRATIME; /* probably even noatime */
490 sb->s_maxbytes = 0xFFFFFFFFU;
491 sb->s_blocksize = 1024; /* Eh... Is this correct? */
492 sb->s_blocksize_bits = 10;
493 sb->s_magic = NCP_SUPER_MAGIC;
494 sb->s_op = &ncp_sops;
495
496 server = NCP_SBP(sb);
497 memset(server, 0, sizeof(*server));
498
499 server->ncp_filp = ncp_filp;
500 server->ncp_sock = sock;
501
502 if (data.info_fd != -1) {
503 struct socket *info_sock;
504
505 error = -EBADF;
506 server->info_filp = fget(data.info_fd);
507 if (!server->info_filp)
508 goto out_fput;
509 error = -ENOTSOCK;
510 sock_inode = server->info_filp->f_dentry->d_inode;
511 if (!S_ISSOCK(sock_inode->i_mode))
512 goto out_fput2;
513 info_sock = SOCKET_I(sock_inode);
514 if (!info_sock)
515 goto out_fput2;
516 error = -EBADFD;
517 if (info_sock->type != SOCK_STREAM)
518 goto out_fput2;
519 server->info_sock = info_sock;
520 }
521
522/* server->lock = 0; */
8e3f9045 523 mutex_init(&server->mutex);
1da177e4
LT		 524 server->packet = NULL;
525/* server->buffer_size = 0; */
526/* server->conn_status = 0; */
527/* server->root_dentry = NULL; */
528/* server->root_setuped = 0; */
529#ifdef CONFIG_NCPFS_PACKET_SIGNING
530/* server->sign_wanted = 0; */
531/* server->sign_active = 0; */
532#endif
533 server->auth.auth_type = NCP_AUTH_NONE;
534/* server->auth.object_name_len = 0; */
535/* server->auth.object_name = NULL; */
536/* server->auth.object_type = 0; */
537/* server->priv.len = 0; */
538/* server->priv.data = NULL; */
539
540 server->m = data;
541 /* Althought anything producing this is buggy, it happens
542 now because of PATH_MAX changes.. */
543 if (server->m.time_out < 1) {
544 server->m.time_out = 10;
545 printk(KERN_INFO "You need to recompile your ncpfs utils..\n");
546 }
547 server->m.time_out = server->m.time_out * HZ / 100;
548 server->m.file_mode = (server->m.file_mode & S_IRWXUGO) | S_IFREG;
549 server->m.dir_mode = (server->m.dir_mode & S_IRWXUGO) | S_IFDIR;
550
551#ifdef CONFIG_NCPFS_NLS
552 /* load the default NLS charsets */
553 server->nls_vol = load_nls_default();
554 server->nls_io = load_nls_default();
555#endif /* CONFIG_NCPFS_NLS */
556
557 server->dentry_ttl = 0; /* no caching */
558
559 INIT_LIST_HEAD(&server->tx.requests);
8e3f9045 560 mutex_init(&server->rcv.creq_mutex);
1da177e4
LT		 561 server->tx.creq = NULL;
562 server->rcv.creq = NULL;
563 server->data_ready = sock->sk->sk_data_ready;
564 server->write_space = sock->sk->sk_write_space;
565 server->error_report = sock->sk->sk_error_report;
566 sock->sk->sk_user_data = server;
567
568 init_timer(&server->timeout_tm);
569#undef NCP_PACKET_SIZE
570#define NCP_PACKET_SIZE 131072
571 error = -ENOMEM;
572 server->packet_size = NCP_PACKET_SIZE;
573 server->packet = vmalloc(NCP_PACKET_SIZE);
574 if (server->packet == NULL)
575 goto out_nls;
576
577 sock->sk->sk_data_ready = ncp_tcp_data_ready;
578 sock->sk->sk_error_report = ncp_tcp_error_report;
579 if (sock->type == SOCK_STREAM) {
580 server->rcv.ptr = (unsigned char*)&server->rcv.buf;
581 server->rcv.len = 10;
582 server->rcv.state = 0;
583 INIT_WORK(&server->rcv.tq, ncp_tcp_rcv_proc, server);
584 INIT_WORK(&server->tx.tq, ncp_tcp_tx_proc, server);
585 sock->sk->sk_write_space = ncp_tcp_write_space;
586 } else {
587 INIT_WORK(&server->rcv.tq, ncpdgram_rcv_proc, server);
588 INIT_WORK(&server->timeout_tq, ncpdgram_timeout_proc, server);
589 server->timeout_tm.data = (unsigned long)server;
590 server->timeout_tm.function = ncpdgram_timeout_call;
591 }
592
593 ncp_lock_server(server);
594 error = ncp_connect(server);
595 ncp_unlock_server(server);
596 if (error < 0)
597 goto out_packet;
598 DPRINTK("ncp_fill_super: NCP_SBP(sb) = %x\n", (int) NCP_SBP(sb));
599
600 error = -EMSGSIZE; /* -EREMOTESIDEINCOMPATIBLE */
601#ifdef CONFIG_NCPFS_PACKET_SIGNING
602 if (ncp_negotiate_size_and_options(server, default_bufsize,
603 NCP_DEFAULT_OPTIONS, &(server->buffer_size), &options) == 0)
604 {
605 if (options != NCP_DEFAULT_OPTIONS)
606 {
607 if (ncp_negotiate_size_and_options(server,
608 default_bufsize,
609 options & 2,
610 &(server->buffer_size), &options) != 0)
611
612 {
613 goto out_disconnect;
614 }
615 }
616 if (options & 2)
617 server->sign_wanted = 1;
618 }
619 else
620#endif /* CONFIG_NCPFS_PACKET_SIGNING */
621 if (ncp_negotiate_buffersize(server, default_bufsize,
622 &(server->buffer_size)) != 0)
623 goto out_disconnect;
624 DPRINTK("ncpfs: bufsize = %d\n", server->buffer_size);
625
626 memset(&finfo, 0, sizeof(finfo));
627 finfo.i.attributes = aDIR;
628 finfo.i.dataStreamSize = 0; /* ignored */
629 finfo.i.dirEntNum = 0;
630 finfo.i.DosDirNum = 0;
631#ifdef CONFIG_NCPFS_SMALLDOS
632 finfo.i.NSCreator = NW_NS_DOS;
633#endif
634 finfo.volume = NCP_NUMBER_OF_VOLUMES;
635 /* set dates of mountpoint to Jan 1, 1986; 00:00 */
636 finfo.i.creationTime = finfo.i.modifyTime
637 = cpu_to_le16(0x0000);
638 finfo.i.creationDate = finfo.i.modifyDate
639 = finfo.i.lastAccessDate
640 = cpu_to_le16(0x0C21);
641 finfo.i.nameLen = 0;
642 finfo.i.entryName[0] = '\0';
643
644 finfo.opened = 0;
645 finfo.ino = 2; /* tradition */
646
647 server->name_space[finfo.volume] = NW_NS_DOS;
648
649 error = -ENOMEM;
650 root_inode = ncp_iget(sb, &finfo);
651 if (!root_inode)
652 goto out_disconnect;
653 DPRINTK("ncp_fill_super: root vol=%d\n", NCP_FINFO(root_inode)->volNumber);
654 sb->s_root = d_alloc_root(root_inode);
655 if (!sb->s_root)
656 goto out_no_root;
657 sb->s_root->d_op = &ncp_root_dentry_operations;
658 return 0;
659
660out_no_root:
661 iput(root_inode);
662out_disconnect:
663 ncp_lock_server(server);
664 ncp_disconnect(server);
665 ncp_unlock_server(server);
666out_packet:
667 ncp_stop_tasks(server);
668 vfree(server->packet);
669out_nls:
670#ifdef CONFIG_NCPFS_NLS
671 unload_nls(server->nls_io);
672 unload_nls(server->nls_vol);
673#endif
674out_fput2:
675 if (server->info_filp)
676 fput(server->info_filp);
677out_fput:
678 /* 23/12/1998 Marcin Dalecki <dalecki@cs.net.pl>:
679 *
680 * The previously used put_filp(ncp_filp); was bogous, since
681 * it doesn't proper unlocking.
682 */
683 fput(ncp_filp);
684out:
685 sb->s_fs_info = NULL;
686 kfree(server);
687 return error;
688}
689
690static void ncp_put_super(struct super_block *sb)
691{
692 struct ncp_server *server = NCP_SBP(sb);
693
694 ncp_lock_server(server);
695 ncp_disconnect(server);
696 ncp_unlock_server(server);
697
698 ncp_stop_tasks(server);
699
700#ifdef CONFIG_NCPFS_NLS
701 /* unload the NLS charsets */
702 if (server->nls_vol)
703 {
704 unload_nls(server->nls_vol);
705 server->nls_vol = NULL;
706 }
707 if (server->nls_io)
708 {
709 unload_nls(server->nls_io);
710 server->nls_io = NULL;
711 }
712#endif /* CONFIG_NCPFS_NLS */
713
714 if (server->info_filp)
715 fput(server->info_filp);
716 fput(server->ncp_filp);
717 kill_proc(server->m.wdog_pid, SIGTERM, 1);
718
44db77f3
PE		 719 kfree(server->priv.data);
720 kfree(server->auth.object_name);
1da177e4
LT		 721 vfree(server->packet);
722 sb->s_fs_info = NULL;
723 kfree(server);
724}
725
726c3342 726static int ncp_statfs(struct dentry *dentry, struct kstatfs *buf)
1da177e4
LT		 727{
728 struct dentry* d;
729 struct inode* i;
730 struct ncp_inode_info* ni;
731 struct ncp_server* s;
732 struct ncp_volume_info vi;
726c3342 733 struct super_block *sb = dentry->d_sb;
1da177e4
LT		 734 int err;
735 __u8 dh;
736
737 d = sb->s_root;
738 if (!d) {
739 goto dflt;
740 }
741 i = d->d_inode;
742 if (!i) {
743 goto dflt;
744 }
745 ni = NCP_FINFO(i);
746 if (!ni) {
747 goto dflt;
748 }
749 s = NCP_SBP(sb);
750 if (!s) {
751 goto dflt;
752 }
753 if (!s->m.mounted_vol[0]) {
754 goto dflt;
755 }
756
757 err = ncp_dirhandle_alloc(s, ni->volNumber, ni->DosDirNum, &dh);
758 if (err) {
759 goto dflt;
760 }
761 err = ncp_get_directory_info(s, dh, &vi);
762 ncp_dirhandle_free(s, dh);
763 if (err) {
764 goto dflt;
765 }
766 buf->f_type = NCP_SUPER_MAGIC;
767 buf->f_bsize = vi.sectors_per_block * 512;
768 buf->f_blocks = vi.total_blocks;
769 buf->f_bfree = vi.free_blocks;
770 buf->f_bavail = vi.free_blocks;
771 buf->f_files = vi.total_dir_entries;
772 buf->f_ffree = vi.available_dir_entries;
773 buf->f_namelen = 12;
774 return 0;
775
776 /* We cannot say how much disk space is left on a mounted
777 NetWare Server, because free space is distributed over
778 volumes, and the current user might have disk quotas. So
779 free space is not that simple to determine. Our decision
780 here is to err conservatively. */
781
782dflt:;
783 buf->f_type = NCP_SUPER_MAGIC;
784 buf->f_bsize = NCP_BLOCK_SIZE;
785 buf->f_blocks = 0;
786 buf->f_bfree = 0;
787 buf->f_bavail = 0;
788 buf->f_namelen = 12;
789 return 0;
790}
791
792int ncp_notify_change(struct dentry *dentry, struct iattr *attr)
793{
794 struct inode *inode = dentry->d_inode;
795 int result = 0;
796 __le32 info_mask;
797 struct nw_modify_dos_info info;
798 struct ncp_server *server;
799
800 result = -EIO;
801
802 lock_kernel();
803
804 server = NCP_SERVER(inode);
805 if ((!server) || !ncp_conn_valid(server))
806 goto out;
807
808 /* ageing the dentry to force validation */
809 ncp_age_dentry(server, dentry);
810
811 result = inode_change_ok(inode, attr);
812 if (result < 0)
813 goto out;
814
815 result = -EPERM;
816 if (((attr->ia_valid & ATTR_UID) &&
817 (attr->ia_uid != server->m.uid)))
818 goto out;
819
820 if (((attr->ia_valid & ATTR_GID) &&
821 (attr->ia_gid != server->m.gid)))
822 goto out;
823
824 if (((attr->ia_valid & ATTR_MODE) &&
825 (attr->ia_mode &
826 ~(S_IFREG | S_IFDIR | S_IRWXUGO))))
827 goto out;
828
829 info_mask = 0;
830 memset(&info, 0, sizeof(info));
831
832#if 1
833 if ((attr->ia_valid & ATTR_MODE) != 0)
834 {
835 umode_t newmode = attr->ia_mode;
836
837 info_mask |= DM_ATTRIBUTES;
838
839 if (S_ISDIR(inode->i_mode)) {
840 newmode &= server->m.dir_mode;
841 } else {
842#ifdef CONFIG_NCPFS_EXTRAS
843 if (server->m.flags & NCP_MOUNT_EXTRAS) {
844 /* any non-default execute bit set */
845 if (newmode & ~server->m.file_mode & S_IXUGO)
846 info.attributes |= aSHARED | aSYSTEM;
847 /* read for group/world and not in default file_mode */
848 else if (newmode & ~server->m.file_mode & S_IRUGO)
849 info.attributes |= aSHARED;
850 } else
851#endif
852 newmode &= server->m.file_mode;
853 }
854 if (newmode & S_IWUGO)
855 info.attributes &= ~(aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
856 else
857 info.attributes |= (aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
858
859#ifdef CONFIG_NCPFS_NFS_NS
860 if (ncp_is_nfs_extras(server, NCP_FINFO(inode)->volNumber)) {
861 result = ncp_modify_nfs_info(server,
862 NCP_FINFO(inode)->volNumber,
863 NCP_FINFO(inode)->dirEntNum,
864 attr->ia_mode, 0);
865 if (result != 0)
866 goto out;
867 info.attributes &= ~(aSHARED | aSYSTEM);
868 {
869 /* mark partial success */
870 struct iattr tmpattr;
871
872 tmpattr.ia_valid = ATTR_MODE;
873 tmpattr.ia_mode = attr->ia_mode;
874
875 result = inode_setattr(inode, &tmpattr);
876 if (result)
877 goto out;
878 }
879 }
880#endif
881 }
882#endif
883
884 /* Do SIZE before attributes, otherwise mtime together with size does not work...
885 */
886 if ((attr->ia_valid & ATTR_SIZE) != 0) {
887 int written;
888
889 DPRINTK("ncpfs: trying to change size to %ld\n",
890 attr->ia_size);
891
892 if ((result = ncp_make_open(inode, O_WRONLY)) < 0) {
893 result = -EACCES;
894 goto out;
895 }
896 ncp_write_kernel(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle,
897 attr->ia_size, 0, "", &written);
898
899 /* According to ndir, the changes only take effect after
900 closing the file */
901 ncp_inode_close(inode);
902 result = ncp_make_closed(inode);
903 if (result)
904 goto out;
905 {
906 struct iattr tmpattr;
907
908 tmpattr.ia_valid = ATTR_SIZE;
909 tmpattr.ia_size = attr->ia_size;
910
911 result = inode_setattr(inode, &tmpattr);
912 if (result)
913 goto out;
914 }
915 }
916 if ((attr->ia_valid & ATTR_CTIME) != 0) {
917 info_mask |= (DM_CREATE_TIME | DM_CREATE_DATE);
918 ncp_date_unix2dos(attr->ia_ctime.tv_sec,
919 &info.creationTime, &info.creationDate);
920 }
921 if ((attr->ia_valid & ATTR_MTIME) != 0) {
922 info_mask |= (DM_MODIFY_TIME | DM_MODIFY_DATE);
923 ncp_date_unix2dos(attr->ia_mtime.tv_sec,
924 &info.modifyTime, &info.modifyDate);
925 }
926 if ((attr->ia_valid & ATTR_ATIME) != 0) {
927 __le16 dummy;
928 info_mask |= (DM_LAST_ACCESS_DATE);
929 ncp_date_unix2dos(attr->ia_atime.tv_sec,
930 &dummy, &info.lastAccessDate);
931 }
932 if (info_mask != 0) {
933 result = ncp_modify_file_or_subdir_dos_info(NCP_SERVER(inode),
934 inode, info_mask, &info);
935 if (result != 0) {
936 result = -EACCES;
937
938 if (info_mask == (DM_CREATE_TIME | DM_CREATE_DATE)) {
939 /* NetWare seems not to allow this. I
940 do not know why. So, just tell the
941 user everything went fine. This is
942 a terrible hack, but I do not know
943 how to do this correctly. */
944 result = 0;
945 } else
946 goto out;
947 }
948#ifdef CONFIG_NCPFS_STRONG
949 if ((!result) && (info_mask & DM_ATTRIBUTES))
950 NCP_FINFO(inode)->nwattr = info.attributes;
951#endif
952 }
953 if (!result)
954 result = inode_setattr(inode, attr);
955out:
956 unlock_kernel();
957 return result;
958}
959
454e2398
DH		 960static int ncp_get_sb(struct file_system_type *fs_type,
961 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
1da177e4 962{
454e2398 963 return get_sb_nodev(fs_type, flags, data, ncp_fill_super, mnt);
1da177e4
LT		 964}
965
966static struct file_system_type ncp_fs_type = {
967 .owner = THIS_MODULE,
968 .name = "ncpfs",
969 .get_sb = ncp_get_sb,
970 .kill_sb = kill_anon_super,
971};
972
973static int __init init_ncp_fs(void)
974{
975 int err;
976 DPRINTK("ncpfs: init_module called\n");
977
1da177e4
LT		 978 err = init_inodecache();
979 if (err)
980 goto out1;
981 err = register_filesystem(&ncp_fs_type);
982 if (err)
983 goto out;
984 return 0;
985out:
986 destroy_inodecache();
987out1:
988 return err;
989}
990
991static void __exit exit_ncp_fs(void)
992{
993 DPRINTK("ncpfs: cleanup_module called\n");
994 unregister_filesystem(&ncp_fs_type);
995 destroy_inodecache();
1da177e4
LT		 996}
997
998module_init(init_ncp_fs)
999module_exit(exit_ncp_fs)
1000MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)