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