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
12 #include <linux/module.h>
14 #include <asm/system.h>
15 #include <asm/uaccess.h>
16 #include <asm/byteorder.h>
18 #include <linux/time.h>
19 #include <linux/kernel.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>
32 #include <linux/ncp_fs.h>
36 #include "ncplib_kernel.h"
39 static void ncp_delete_inode(struct inode
*);
40 static void ncp_put_super(struct super_block
*);
41 static int ncp_statfs(struct dentry
*, struct kstatfs
*);
43 static kmem_cache_t
* ncp_inode_cachep
;
45 static struct inode
*ncp_alloc_inode(struct super_block
*sb
)
47 struct ncp_inode_info
*ei
;
48 ei
= (struct ncp_inode_info
*)kmem_cache_alloc(ncp_inode_cachep
, SLAB_KERNEL
);
51 return &ei
->vfs_inode
;
54 static void ncp_destroy_inode(struct inode
*inode
)
56 kmem_cache_free(ncp_inode_cachep
, NCP_FINFO(inode
));
59 static void init_once(void * foo
, kmem_cache_t
* cachep
, unsigned long flags
)
61 struct ncp_inode_info
*ei
= (struct ncp_inode_info
*) foo
;
63 if ((flags
& (SLAB_CTOR_VERIFY
|SLAB_CTOR_CONSTRUCTOR
)) ==
64 SLAB_CTOR_CONSTRUCTOR
) {
65 mutex_init(&ei
->open_mutex
);
66 inode_init_once(&ei
->vfs_inode
);
70 static int init_inodecache(void)
72 ncp_inode_cachep
= kmem_cache_create("ncp_inode_cache",
73 sizeof(struct ncp_inode_info
),
74 0, (SLAB_RECLAIM_ACCOUNT
|
77 if (ncp_inode_cachep
== NULL
)
82 static void destroy_inodecache(void)
84 if (kmem_cache_destroy(ncp_inode_cachep
))
85 printk(KERN_INFO
"ncp_inode_cache: not all structures were freed\n");
88 static int ncp_remount(struct super_block
*sb
, int *flags
, char* data
)
90 *flags
|= MS_NODIRATIME
;
94 static struct super_operations ncp_sops
=
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
,
105 extern struct dentry_operations ncp_root_dentry_operations
;
106 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
107 extern const struct address_space_operations ncp_symlink_aops
;
108 extern int ncp_symlink(struct inode
*, struct dentry
*, const char*);
112 * Fill in the ncpfs-specific information in the inode.
114 static void ncp_update_dirent(struct inode
*inode
, struct ncp_entry_info
*nwinfo
)
116 NCP_FINFO(inode
)->DosDirNum
= nwinfo
->i
.DosDirNum
;
117 NCP_FINFO(inode
)->dirEntNum
= nwinfo
->i
.dirEntNum
;
118 NCP_FINFO(inode
)->volNumber
= nwinfo
->volume
;
121 void ncp_update_inode(struct inode
*inode
, struct ncp_entry_info
*nwinfo
)
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
);
133 static void ncp_update_dates(struct inode
*inode
, struct nw_info_struct
*nwi
)
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
);
140 inode
->i_mode
= nwi
->nfs
.mode
;
143 inode
->i_blocks
= (inode
->i_size
+ NCP_BLOCK_SIZE
- 1) >> NCP_BLOCK_SHIFT
;
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;
153 static void ncp_update_attrs(struct inode
*inode
, struct ncp_entry_info
*nwinfo
)
155 struct nw_info_struct
*nwi
= &nwinfo
->i
;
156 struct ncp_server
*server
= NCP_SERVER(inode
);
158 if (nwi
->attributes
& aDIR
) {
159 inode
->i_mode
= server
->m
.dir_mode
;
160 /* for directories dataStreamSize seems to be some
162 inode
->i_size
= NCP_BLOCK_SIZE
;
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
)) {
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
;
181 if (server
->m
.flags
& NCP_MOUNT_EXTRAS
)
182 inode
->i_mode
|= S_IRUGO
;
185 if (server
->m
.flags
& NCP_MOUNT_EXTRAS
)
186 inode
->i_mode
|= (inode
->i_mode
>> 2) & S_IXUGO
;
188 /* case aSYSTEM|aHIDDEN: */
190 /* reserved combination */
196 if (nwi
->attributes
& aRONLY
) inode
->i_mode
&= ~S_IWUGO
;
199 void ncp_update_inode2(struct inode
* inode
, struct ncp_entry_info
*nwinfo
)
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
);
207 ncp_update_dates(inode
, &nwinfo
->i
);
208 ncp_update_dirent(inode
, nwinfo
);
212 * Fill in the inode based on the ncp_entry_info structure.
214 static void ncp_set_attr(struct inode
*inode
, struct ncp_entry_info
*nwinfo
)
216 struct ncp_server
*server
= NCP_SERVER(inode
);
218 NCP_FINFO(inode
)->flags
= 0;
220 ncp_update_attrs(inode
, nwinfo
);
222 DDPRINTK("ncp_read_inode: inode->i_mode = %u\n", inode
->i_mode
);
225 inode
->i_uid
= server
->m
.uid
;
226 inode
->i_gid
= server
->m
.gid
;
227 inode
->i_blksize
= NCP_BLOCK_SIZE
;
229 ncp_update_dates(inode
, &nwinfo
->i
);
230 ncp_update_inode(inode
, nwinfo
);
233 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
234 static 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
,
246 ncp_iget(struct super_block
*sb
, struct ncp_entry_info
*info
)
251 printk(KERN_ERR
"ncp_iget: info is NULL\n");
255 inode
= new_inode(sb
);
257 atomic_set(&NCP_FINFO(inode
)->opened
, info
->opened
);
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
));
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
;
278 make_bad_inode(inode
);
280 insert_inode_hash(inode
);
282 printk(KERN_ERR
"ncp_iget: iget failed!\n");
287 ncp_delete_inode(struct inode
*inode
)
289 truncate_inode_pages(&inode
->i_data
, 0);
291 if (S_ISDIR(inode
->i_mode
)) {
292 DDPRINTK("ncp_delete_inode: put directory %ld\n", inode
->i_ino
);
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");
302 static void ncp_stop_tasks(struct ncp_server
*server
) {
303 struct sock
* sk
= server
->ncp_sock
->sk
;
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();
312 static 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' },
327 static int ncp_parse_options(struct ncp_mount_data_kernel
*data
, char *options
) {
330 unsigned long optint
;
335 data
->mounted_uid
= 0;
339 data
->retry_count
= 20;
342 data
->file_mode
= 0600;
343 data
->dir_mode
= 0700;
345 data
->mounted_vol
[0] = 0;
347 while ((optval
= ncp_getopt("ncpfs", &options
, ncp_opts
, NULL
, &optarg
, &optint
)) != 0) {
358 data
->mounted_uid
= optint
;
361 data
->file_mode
= optint
;
364 data
->dir_mode
= optint
;
367 data
->time_out
= optint
;
370 data
->retry_count
= optint
;
373 data
->flags
= optint
;
376 data
->wdog_pid
= optint
;
379 data
->ncp_fd
= optint
;
382 data
->info_fd
= optint
;
385 if (optint
< NCP_MOUNT_VERSION_V4
) {
388 if (optint
> NCP_MOUNT_VERSION_V5
) {
399 static int ncp_fill_super(struct super_block
*sb
, void *raw_data
, int silent
)
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
;
409 #ifdef CONFIG_NCPFS_PACKET_SIGNING
412 struct ncp_entry_info finfo
;
414 server
= kzalloc(sizeof(struct ncp_server
), GFP_KERNEL
);
417 sb
->s_fs_info
= server
;
420 if (raw_data
== NULL
)
422 switch (*(int*)raw_data
) {
423 case NCP_MOUNT_VERSION
:
425 struct ncp_mount_data
* md
= (struct ncp_mount_data
*)raw_data
;
427 data
.flags
= md
->flags
;
428 data
.int_flags
= NCP_IMOUNT_LOGGEDIN_POSSIBLE
;
429 data
.mounted_uid
= md
->mounted_uid
;
430 data
.wdog_pid
= md
->wdog_pid
;
431 data
.ncp_fd
= md
->ncp_fd
;
432 data
.time_out
= md
->time_out
;
433 data
.retry_count
= md
->retry_count
;
436 data
.file_mode
= md
->file_mode
;
437 data
.dir_mode
= md
->dir_mode
;
439 memcpy(data
.mounted_vol
, md
->mounted_vol
,
443 case NCP_MOUNT_VERSION_V4
:
445 struct ncp_mount_data_v4
* md
= (struct ncp_mount_data_v4
*)raw_data
;
447 data
.flags
= md
->flags
;
449 data
.mounted_uid
= md
->mounted_uid
;
450 data
.wdog_pid
= md
->wdog_pid
;
451 data
.ncp_fd
= md
->ncp_fd
;
452 data
.time_out
= md
->time_out
;
453 data
.retry_count
= md
->retry_count
;
456 data
.file_mode
= md
->file_mode
;
457 data
.dir_mode
= md
->dir_mode
;
459 data
.mounted_vol
[0] = 0;
464 if (memcmp(raw_data
, "vers", 4) == 0) {
465 error
= ncp_parse_options(&data
, raw_data
);
472 ncp_filp
= fget(data
.ncp_fd
);
476 sock_inode
= ncp_filp
->f_dentry
->d_inode
;
477 if (!S_ISSOCK(sock_inode
->i_mode
))
479 sock
= SOCKET_I(sock_inode
);
483 if (sock
->type
== SOCK_STREAM
)
484 default_bufsize
= 0xF000;
486 default_bufsize
= 1024;
488 sb
->s_flags
|= MS_NODIRATIME
; /* probably even noatime */
489 sb
->s_maxbytes
= 0xFFFFFFFFU
;
490 sb
->s_blocksize
= 1024; /* Eh... Is this correct? */
491 sb
->s_blocksize_bits
= 10;
492 sb
->s_magic
= NCP_SUPER_MAGIC
;
493 sb
->s_op
= &ncp_sops
;
495 server
= NCP_SBP(sb
);
496 memset(server
, 0, sizeof(*server
));
498 server
->ncp_filp
= ncp_filp
;
499 server
->ncp_sock
= sock
;
501 if (data
.info_fd
!= -1) {
502 struct socket
*info_sock
;
505 server
->info_filp
= fget(data
.info_fd
);
506 if (!server
->info_filp
)
509 sock_inode
= server
->info_filp
->f_dentry
->d_inode
;
510 if (!S_ISSOCK(sock_inode
->i_mode
))
512 info_sock
= SOCKET_I(sock_inode
);
516 if (info_sock
->type
!= SOCK_STREAM
)
518 server
->info_sock
= info_sock
;
521 /* server->lock = 0; */
522 mutex_init(&server
->mutex
);
523 server
->packet
= NULL
;
524 /* server->buffer_size = 0; */
525 /* server->conn_status = 0; */
526 /* server->root_dentry = NULL; */
527 /* server->root_setuped = 0; */
528 #ifdef CONFIG_NCPFS_PACKET_SIGNING
529 /* server->sign_wanted = 0; */
530 /* server->sign_active = 0; */
532 server
->auth
.auth_type
= NCP_AUTH_NONE
;
533 /* server->auth.object_name_len = 0; */
534 /* server->auth.object_name = NULL; */
535 /* server->auth.object_type = 0; */
536 /* server->priv.len = 0; */
537 /* server->priv.data = NULL; */
540 /* Althought anything producing this is buggy, it happens
541 now because of PATH_MAX changes.. */
542 if (server
->m
.time_out
< 1) {
543 server
->m
.time_out
= 10;
544 printk(KERN_INFO
"You need to recompile your ncpfs utils..\n");
546 server
->m
.time_out
= server
->m
.time_out
* HZ
/ 100;
547 server
->m
.file_mode
= (server
->m
.file_mode
& S_IRWXUGO
) | S_IFREG
;
548 server
->m
.dir_mode
= (server
->m
.dir_mode
& S_IRWXUGO
) | S_IFDIR
;
550 #ifdef CONFIG_NCPFS_NLS
551 /* load the default NLS charsets */
552 server
->nls_vol
= load_nls_default();
553 server
->nls_io
= load_nls_default();
554 #endif /* CONFIG_NCPFS_NLS */
556 server
->dentry_ttl
= 0; /* no caching */
558 INIT_LIST_HEAD(&server
->tx
.requests
);
559 mutex_init(&server
->rcv
.creq_mutex
);
560 server
->tx
.creq
= NULL
;
561 server
->rcv
.creq
= NULL
;
562 server
->data_ready
= sock
->sk
->sk_data_ready
;
563 server
->write_space
= sock
->sk
->sk_write_space
;
564 server
->error_report
= sock
->sk
->sk_error_report
;
565 sock
->sk
->sk_user_data
= server
;
567 init_timer(&server
->timeout_tm
);
568 #undef NCP_PACKET_SIZE
569 #define NCP_PACKET_SIZE 131072
571 server
->packet_size
= NCP_PACKET_SIZE
;
572 server
->packet
= vmalloc(NCP_PACKET_SIZE
);
573 if (server
->packet
== NULL
)
576 sock
->sk
->sk_data_ready
= ncp_tcp_data_ready
;
577 sock
->sk
->sk_error_report
= ncp_tcp_error_report
;
578 if (sock
->type
== SOCK_STREAM
) {
579 server
->rcv
.ptr
= (unsigned char*)&server
->rcv
.buf
;
580 server
->rcv
.len
= 10;
581 server
->rcv
.state
= 0;
582 INIT_WORK(&server
->rcv
.tq
, ncp_tcp_rcv_proc
, server
);
583 INIT_WORK(&server
->tx
.tq
, ncp_tcp_tx_proc
, server
);
584 sock
->sk
->sk_write_space
= ncp_tcp_write_space
;
586 INIT_WORK(&server
->rcv
.tq
, ncpdgram_rcv_proc
, server
);
587 INIT_WORK(&server
->timeout_tq
, ncpdgram_timeout_proc
, server
);
588 server
->timeout_tm
.data
= (unsigned long)server
;
589 server
->timeout_tm
.function
= ncpdgram_timeout_call
;
592 ncp_lock_server(server
);
593 error
= ncp_connect(server
);
594 ncp_unlock_server(server
);
597 DPRINTK("ncp_fill_super: NCP_SBP(sb) = %x\n", (int) NCP_SBP(sb
));
599 error
= -EMSGSIZE
; /* -EREMOTESIDEINCOMPATIBLE */
600 #ifdef CONFIG_NCPFS_PACKET_SIGNING
601 if (ncp_negotiate_size_and_options(server
, default_bufsize
,
602 NCP_DEFAULT_OPTIONS
, &(server
->buffer_size
), &options
) == 0)
604 if (options
!= NCP_DEFAULT_OPTIONS
)
606 if (ncp_negotiate_size_and_options(server
,
609 &(server
->buffer_size
), &options
) != 0)
616 server
->sign_wanted
= 1;
619 #endif /* CONFIG_NCPFS_PACKET_SIGNING */
620 if (ncp_negotiate_buffersize(server
, default_bufsize
,
621 &(server
->buffer_size
)) != 0)
623 DPRINTK("ncpfs: bufsize = %d\n", server
->buffer_size
);
625 memset(&finfo
, 0, sizeof(finfo
));
626 finfo
.i
.attributes
= aDIR
;
627 finfo
.i
.dataStreamSize
= 0; /* ignored */
628 finfo
.i
.dirEntNum
= 0;
629 finfo
.i
.DosDirNum
= 0;
630 #ifdef CONFIG_NCPFS_SMALLDOS
631 finfo
.i
.NSCreator
= NW_NS_DOS
;
633 finfo
.volume
= NCP_NUMBER_OF_VOLUMES
;
634 /* set dates of mountpoint to Jan 1, 1986; 00:00 */
635 finfo
.i
.creationTime
= finfo
.i
.modifyTime
636 = cpu_to_le16(0x0000);
637 finfo
.i
.creationDate
= finfo
.i
.modifyDate
638 = finfo
.i
.lastAccessDate
639 = cpu_to_le16(0x0C21);
641 finfo
.i
.entryName
[0] = '\0';
644 finfo
.ino
= 2; /* tradition */
646 server
->name_space
[finfo
.volume
] = NW_NS_DOS
;
649 root_inode
= ncp_iget(sb
, &finfo
);
652 DPRINTK("ncp_fill_super: root vol=%d\n", NCP_FINFO(root_inode
)->volNumber
);
653 sb
->s_root
= d_alloc_root(root_inode
);
656 sb
->s_root
->d_op
= &ncp_root_dentry_operations
;
662 ncp_lock_server(server
);
663 ncp_disconnect(server
);
664 ncp_unlock_server(server
);
666 ncp_stop_tasks(server
);
667 vfree(server
->packet
);
669 #ifdef CONFIG_NCPFS_NLS
670 unload_nls(server
->nls_io
);
671 unload_nls(server
->nls_vol
);
674 if (server
->info_filp
)
675 fput(server
->info_filp
);
677 /* 23/12/1998 Marcin Dalecki <dalecki@cs.net.pl>:
679 * The previously used put_filp(ncp_filp); was bogous, since
680 * it doesn't proper unlocking.
684 sb
->s_fs_info
= NULL
;
689 static void ncp_put_super(struct super_block
*sb
)
691 struct ncp_server
*server
= NCP_SBP(sb
);
693 ncp_lock_server(server
);
694 ncp_disconnect(server
);
695 ncp_unlock_server(server
);
697 ncp_stop_tasks(server
);
699 #ifdef CONFIG_NCPFS_NLS
700 /* unload the NLS charsets */
703 unload_nls(server
->nls_vol
);
704 server
->nls_vol
= NULL
;
708 unload_nls(server
->nls_io
);
709 server
->nls_io
= NULL
;
711 #endif /* CONFIG_NCPFS_NLS */
713 if (server
->info_filp
)
714 fput(server
->info_filp
);
715 fput(server
->ncp_filp
);
716 kill_proc(server
->m
.wdog_pid
, SIGTERM
, 1);
718 kfree(server
->priv
.data
);
719 kfree(server
->auth
.object_name
);
720 vfree(server
->packet
);
721 sb
->s_fs_info
= NULL
;
725 static int ncp_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
729 struct ncp_inode_info
* ni
;
730 struct ncp_server
* s
;
731 struct ncp_volume_info vi
;
732 struct super_block
*sb
= dentry
->d_sb
;
752 if (!s
->m
.mounted_vol
[0]) {
756 err
= ncp_dirhandle_alloc(s
, ni
->volNumber
, ni
->DosDirNum
, &dh
);
760 err
= ncp_get_directory_info(s
, dh
, &vi
);
761 ncp_dirhandle_free(s
, dh
);
765 buf
->f_type
= NCP_SUPER_MAGIC
;
766 buf
->f_bsize
= vi
.sectors_per_block
* 512;
767 buf
->f_blocks
= vi
.total_blocks
;
768 buf
->f_bfree
= vi
.free_blocks
;
769 buf
->f_bavail
= vi
.free_blocks
;
770 buf
->f_files
= vi
.total_dir_entries
;
771 buf
->f_ffree
= vi
.available_dir_entries
;
775 /* We cannot say how much disk space is left on a mounted
776 NetWare Server, because free space is distributed over
777 volumes, and the current user might have disk quotas. So
778 free space is not that simple to determine. Our decision
779 here is to err conservatively. */
782 buf
->f_type
= NCP_SUPER_MAGIC
;
783 buf
->f_bsize
= NCP_BLOCK_SIZE
;
791 int ncp_notify_change(struct dentry
*dentry
, struct iattr
*attr
)
793 struct inode
*inode
= dentry
->d_inode
;
796 struct nw_modify_dos_info info
;
797 struct ncp_server
*server
;
803 server
= NCP_SERVER(inode
);
804 if ((!server
) || !ncp_conn_valid(server
))
807 /* ageing the dentry to force validation */
808 ncp_age_dentry(server
, dentry
);
810 result
= inode_change_ok(inode
, attr
);
815 if (((attr
->ia_valid
& ATTR_UID
) &&
816 (attr
->ia_uid
!= server
->m
.uid
)))
819 if (((attr
->ia_valid
& ATTR_GID
) &&
820 (attr
->ia_gid
!= server
->m
.gid
)))
823 if (((attr
->ia_valid
& ATTR_MODE
) &&
825 ~(S_IFREG
| S_IFDIR
| S_IRWXUGO
))))
829 memset(&info
, 0, sizeof(info
));
832 if ((attr
->ia_valid
& ATTR_MODE
) != 0)
834 umode_t newmode
= attr
->ia_mode
;
836 info_mask
|= DM_ATTRIBUTES
;
838 if (S_ISDIR(inode
->i_mode
)) {
839 newmode
&= server
->m
.dir_mode
;
841 #ifdef CONFIG_NCPFS_EXTRAS
842 if (server
->m
.flags
& NCP_MOUNT_EXTRAS
) {
843 /* any non-default execute bit set */
844 if (newmode
& ~server
->m
.file_mode
& S_IXUGO
)
845 info
.attributes
|= aSHARED
| aSYSTEM
;
846 /* read for group/world and not in default file_mode */
847 else if (newmode
& ~server
->m
.file_mode
& S_IRUGO
)
848 info
.attributes
|= aSHARED
;
851 newmode
&= server
->m
.file_mode
;
853 if (newmode
& S_IWUGO
)
854 info
.attributes
&= ~(aRONLY
|aRENAMEINHIBIT
|aDELETEINHIBIT
);
856 info
.attributes
|= (aRONLY
|aRENAMEINHIBIT
|aDELETEINHIBIT
);
858 #ifdef CONFIG_NCPFS_NFS_NS
859 if (ncp_is_nfs_extras(server
, NCP_FINFO(inode
)->volNumber
)) {
860 result
= ncp_modify_nfs_info(server
,
861 NCP_FINFO(inode
)->volNumber
,
862 NCP_FINFO(inode
)->dirEntNum
,
866 info
.attributes
&= ~(aSHARED
| aSYSTEM
);
868 /* mark partial success */
869 struct iattr tmpattr
;
871 tmpattr
.ia_valid
= ATTR_MODE
;
872 tmpattr
.ia_mode
= attr
->ia_mode
;
874 result
= inode_setattr(inode
, &tmpattr
);
883 /* Do SIZE before attributes, otherwise mtime together with size does not work...
885 if ((attr
->ia_valid
& ATTR_SIZE
) != 0) {
888 DPRINTK("ncpfs: trying to change size to %ld\n",
891 if ((result
= ncp_make_open(inode
, O_WRONLY
)) < 0) {
895 ncp_write_kernel(NCP_SERVER(inode
), NCP_FINFO(inode
)->file_handle
,
896 attr
->ia_size
, 0, "", &written
);
898 /* According to ndir, the changes only take effect after
900 ncp_inode_close(inode
);
901 result
= ncp_make_closed(inode
);
905 struct iattr tmpattr
;
907 tmpattr
.ia_valid
= ATTR_SIZE
;
908 tmpattr
.ia_size
= attr
->ia_size
;
910 result
= inode_setattr(inode
, &tmpattr
);
915 if ((attr
->ia_valid
& ATTR_CTIME
) != 0) {
916 info_mask
|= (DM_CREATE_TIME
| DM_CREATE_DATE
);
917 ncp_date_unix2dos(attr
->ia_ctime
.tv_sec
,
918 &info
.creationTime
, &info
.creationDate
);
920 if ((attr
->ia_valid
& ATTR_MTIME
) != 0) {
921 info_mask
|= (DM_MODIFY_TIME
| DM_MODIFY_DATE
);
922 ncp_date_unix2dos(attr
->ia_mtime
.tv_sec
,
923 &info
.modifyTime
, &info
.modifyDate
);
925 if ((attr
->ia_valid
& ATTR_ATIME
) != 0) {
927 info_mask
|= (DM_LAST_ACCESS_DATE
);
928 ncp_date_unix2dos(attr
->ia_atime
.tv_sec
,
929 &dummy
, &info
.lastAccessDate
);
931 if (info_mask
!= 0) {
932 result
= ncp_modify_file_or_subdir_dos_info(NCP_SERVER(inode
),
933 inode
, info_mask
, &info
);
937 if (info_mask
== (DM_CREATE_TIME
| DM_CREATE_DATE
)) {
938 /* NetWare seems not to allow this. I
939 do not know why. So, just tell the
940 user everything went fine. This is
941 a terrible hack, but I do not know
942 how to do this correctly. */
947 #ifdef CONFIG_NCPFS_STRONG
948 if ((!result
) && (info_mask
& DM_ATTRIBUTES
))
949 NCP_FINFO(inode
)->nwattr
= info
.attributes
;
953 result
= inode_setattr(inode
, attr
);
959 static int ncp_get_sb(struct file_system_type
*fs_type
,
960 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
962 return get_sb_nodev(fs_type
, flags
, data
, ncp_fill_super
, mnt
);
965 static struct file_system_type ncp_fs_type
= {
966 .owner
= THIS_MODULE
,
968 .get_sb
= ncp_get_sb
,
969 .kill_sb
= kill_anon_super
,
972 static int __init
init_ncp_fs(void)
975 DPRINTK("ncpfs: init_module called\n");
977 err
= init_inodecache();
980 err
= register_filesystem(&ncp_fs_type
);
985 destroy_inodecache();
990 static void __exit
exit_ncp_fs(void)
992 DPRINTK("ncpfs: cleanup_module called\n");
993 unregister_filesystem(&ncp_fs_type
);
994 destroy_inodecache();
997 module_init(init_ncp_fs
)
998 module_exit(exit_ncp_fs
)
999 MODULE_LICENSE("GPL");