4 * Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke
5 * Copyright (C) 1997 by Volker Lendecke
9 #include <linux/module.h>
10 #include <linux/sched.h>
11 #include <linux/kernel.h>
13 #include <linux/string.h>
14 #include <linux/stat.h>
15 #include <linux/errno.h>
16 #include <linux/locks.h>
17 #include <linux/malloc.h>
18 #include <linux/init.h>
19 #include <linux/file.h>
20 #include <linux/dcache.h>
21 #include <linux/smp_lock.h>
23 #include <linux/smb_fs.h>
24 #include <linux/smbno.h>
25 #include <linux/smb_mount.h>
27 #include <asm/system.h>
28 #include <asm/uaccess.h>
30 #define SMBFS_PARANOIA 1
31 /* #define SMBFS_DEBUG_VERBOSE 1 */
33 static void smb_delete_inode(struct inode
*);
34 static void smb_put_super(struct super_block
*);
35 static int smb_statfs(struct super_block
*, struct statfs
*);
36 static void smb_set_inode_attr(struct inode
*, struct smb_fattr
*);
38 static struct super_operations smb_sops
=
40 put_inode
: force_delete
,
41 delete_inode
: smb_delete_inode
,
42 put_super
: smb_put_super
,
46 /* FIXME: Look at all inodes whether so that we do not get duplicate
50 smb_invent_inos(unsigned long n
)
52 static unsigned long ino
= 2;
63 /* We are always generating a new inode here */
65 smb_iget(struct super_block
*sb
, struct smb_fattr
*fattr
)
69 pr_debug("smb_iget: %p\n", fattr
);
71 result
= get_empty_inode();
75 result
->i_dev
= sb
->s_dev
;
76 result
->i_ino
= fattr
->f_ino
;
77 memset(&(result
->u
.smbfs_i
), 0, sizeof(result
->u
.smbfs_i
));
78 smb_set_inode_attr(result
, fattr
);
79 if (S_ISREG(result
->i_mode
)) {
80 result
->i_op
= &smb_file_inode_operations
;
81 result
->i_fop
= &smb_file_operations
;
82 result
->i_data
.a_ops
= &smb_file_aops
;
83 } else if (S_ISDIR(result
->i_mode
)) {
84 result
->i_op
= &smb_dir_inode_operations
;
85 result
->i_fop
= &smb_dir_operations
;
87 insert_inode_hash(result
);
92 * Copy the inode data to a smb_fattr structure.
95 smb_get_inode_attr(struct inode
*inode
, struct smb_fattr
*fattr
)
97 memset(fattr
, 0, sizeof(struct smb_fattr
));
98 fattr
->f_mode
= inode
->i_mode
;
99 fattr
->f_nlink
= inode
->i_nlink
;
100 fattr
->f_ino
= inode
->i_ino
;
101 fattr
->f_uid
= inode
->i_uid
;
102 fattr
->f_gid
= inode
->i_gid
;
103 fattr
->f_rdev
= inode
->i_rdev
;
104 fattr
->f_size
= inode
->i_size
;
105 fattr
->f_mtime
= inode
->i_mtime
;
106 fattr
->f_ctime
= inode
->i_ctime
;
107 fattr
->f_atime
= inode
->i_atime
;
108 fattr
->f_blksize
= inode
->i_blksize
;
109 fattr
->f_blocks
= inode
->i_blocks
;
111 fattr
->attr
= inode
->u
.smbfs_i
.attr
;
113 * Keep the attributes in sync with the inode permissions.
115 if (fattr
->f_mode
& S_IWUSR
)
116 fattr
->attr
&= ~aRONLY
;
118 fattr
->attr
|= aRONLY
;
122 smb_set_inode_attr(struct inode
*inode
, struct smb_fattr
*fattr
)
124 inode
->i_mode
= fattr
->f_mode
;
125 inode
->i_nlink
= fattr
->f_nlink
;
126 inode
->i_uid
= fattr
->f_uid
;
127 inode
->i_gid
= fattr
->f_gid
;
128 inode
->i_rdev
= fattr
->f_rdev
;
129 inode
->i_ctime
= fattr
->f_ctime
;
130 inode
->i_blksize
= fattr
->f_blksize
;
131 inode
->i_blocks
= fattr
->f_blocks
;
133 * Don't change the size and mtime/atime fields
134 * if we're writing to the file.
136 if (!(inode
->u
.smbfs_i
.cache_valid
& SMB_F_LOCALWRITE
))
138 inode
->i_size
= fattr
->f_size
;
139 inode
->i_mtime
= fattr
->f_mtime
;
140 inode
->i_atime
= fattr
->f_atime
;
143 inode
->u
.smbfs_i
.attr
= fattr
->attr
;
145 * Update the "last time refreshed" field for revalidation.
147 inode
->u
.smbfs_i
.oldmtime
= jiffies
;
151 * This is called if the connection has gone bad ...
152 * try to kill off all the current inodes.
155 smb_invalidate_inodes(struct smb_sb_info
*server
)
157 #ifdef SMBFS_DEBUG_VERBOSE
158 printk("smb_invalidate_inodes\n");
160 shrink_dcache_sb(SB_of(server
));
161 invalidate_inodes(SB_of(server
));
165 * This is called to update the inode attributes after
166 * we've made changes to a file or directory.
169 smb_refresh_inode(struct dentry
*dentry
)
171 struct inode
*inode
= dentry
->d_inode
;
173 struct smb_fattr fattr
;
175 error
= smb_proc_getattr(dentry
, &fattr
);
178 smb_renew_times(dentry
);
180 * Check whether the type part of the mode changed,
181 * and don't update the attributes if it did.
183 if ((inode
->i_mode
& S_IFMT
) == (fattr
.f_mode
& S_IFMT
))
184 smb_set_inode_attr(inode
, &fattr
);
188 * Big trouble! The inode has become a new object,
189 * so any operations attempted on it are invalid.
191 * To limit damage, mark the inode as bad so that
192 * subsequent lookup validations will fail.
194 #ifdef SMBFS_PARANOIA
195 printk("smb_refresh_inode: %s/%s changed mode, %07o to %07o\n",
196 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
,
197 inode
->i_mode
, fattr
.f_mode
);
199 fattr
.f_mode
= inode
->i_mode
; /* save mode */
200 make_bad_inode(inode
);
201 inode
->i_mode
= fattr
.f_mode
; /* restore mode */
203 * No need to worry about unhashing the dentry: the
204 * lookup validation will see that the inode is bad.
205 * But we do want to invalidate the caches ...
207 if (!S_ISDIR(inode
->i_mode
))
208 invalidate_inode_pages(inode
);
210 smb_invalid_dir_cache(inode
);
218 * This is called when we want to check whether the inode
219 * has changed on the server. If it has changed, we must
220 * invalidate our local caches.
223 smb_revalidate_inode(struct dentry
*dentry
)
225 struct inode
*inode
= dentry
->d_inode
;
229 pr_debug("smb_revalidate_inode\n");
231 * If this is a file opened with write permissions,
232 * the inode will be up-to-date.
235 if (S_ISREG(inode
->i_mode
) && smb_is_open(inode
))
237 if (inode
->u
.smbfs_i
.access
!= SMB_O_RDONLY
)
242 * Check whether we've recently refreshed the inode.
244 if (time_before(jiffies
, inode
->u
.smbfs_i
.oldmtime
+ HZ
/10))
246 #ifdef SMBFS_DEBUG_VERBOSE
247 printk("smb_revalidate_inode: up-to-date, jiffies=%lu, oldtime=%lu\n",
248 jiffies
, inode
->u
.smbfs_i
.oldmtime
);
254 * Save the last modified time, then refresh the inode.
255 * (Note: a size change should have a different mtime.)
257 last_time
= inode
->i_mtime
;
258 error
= smb_refresh_inode(dentry
);
259 if (error
|| inode
->i_mtime
!= last_time
)
261 #ifdef SMBFS_DEBUG_VERBOSE
262 printk("smb_revalidate: %s/%s changed, old=%ld, new=%ld\n",
263 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
,
264 (long) last_time
, (long) inode
->i_mtime
);
266 if (!S_ISDIR(inode
->i_mode
))
267 invalidate_inode_pages(inode
);
269 smb_invalid_dir_cache(inode
);
277 * This routine is called when i_nlink == 0 and i_count goes to 0.
278 * All blocking cleanup operations need to go here to avoid races.
281 smb_delete_inode(struct inode
*ino
)
283 pr_debug("smb_delete_inode\n");
286 printk("smb_delete_inode: could not close inode %ld\n",
293 smb_put_super(struct super_block
*sb
)
295 struct smb_sb_info
*server
= &(sb
->u
.smbfs_sb
);
297 if (server
->sock_file
) {
298 smb_proc_disconnect(server
);
299 smb_dont_catch_keepalive(server
);
300 fput(server
->sock_file
);
303 if (server
->conn_pid
)
304 kill_proc(server
->conn_pid
, SIGTERM
, 1);
307 kfree(sb
->u
.smbfs_sb
.temp_buf
);
309 smb_vfree(server
->packet
);
313 smb_read_super(struct super_block
*sb
, void *raw_data
, int silent
)
315 struct smb_mount_data
*mnt
;
316 struct inode
*root_inode
;
317 struct smb_fattr root
;
321 if (((struct smb_mount_data
*) raw_data
)->version
!= SMB_MOUNT_VERSION
)
324 sb
->s_blocksize
= 1024; /* Eh... Is this correct? */
325 sb
->s_blocksize_bits
= 10;
326 sb
->s_magic
= SMB_SUPER_MAGIC
;
328 sb
->s_op
= &smb_sops
;
330 sb
->u
.smbfs_sb
.sock_file
= NULL
;
331 init_MUTEX(&sb
->u
.smbfs_sb
.sem
);
332 init_waitqueue_head(&sb
->u
.smbfs_sb
.wait
);
333 sb
->u
.smbfs_sb
.conn_pid
= 0;
334 sb
->u
.smbfs_sb
.state
= CONN_INVALID
; /* no connection yet */
335 sb
->u
.smbfs_sb
.generation
= 0;
336 sb
->u
.smbfs_sb
.packet_size
= smb_round_length(SMB_INITIAL_PACKET_SIZE
);
337 sb
->u
.smbfs_sb
.packet
= smb_vmalloc(sb
->u
.smbfs_sb
.packet_size
);
338 if (!sb
->u
.smbfs_sb
.packet
)
341 /* Allocate the global temp buffer */
342 sb
->u
.smbfs_sb
.temp_buf
= kmalloc(SMB_MAXPATHLEN
+ 20, GFP_KERNEL
);
343 if (!sb
->u
.smbfs_sb
.temp_buf
)
346 /* Allocate the mount data structure */
347 mnt
= kmalloc(sizeof(struct smb_mount_data
), GFP_KERNEL
);
350 *mnt
= *((struct smb_mount_data
*) raw_data
);
351 /* ** temp ** pass config flags in file mode */
352 mnt
->version
= (mnt
->file_mode
>> 9);
353 mnt
->file_mode
&= (S_IRWXU
| S_IRWXG
| S_IRWXO
);
354 mnt
->file_mode
|= S_IFREG
;
355 mnt
->dir_mode
&= (S_IRWXU
| S_IRWXG
| S_IRWXO
);
356 mnt
->dir_mode
|= S_IFDIR
;
357 sb
->u
.smbfs_sb
.mnt
= mnt
;
359 * Display the enabled options
361 if (mnt
->version
& SMB_FIX_OLDATTR
)
362 printk("SMBFS: Using core getattr (Win 95 speedup)\n");
363 else if (mnt
->version
& SMB_FIX_DIRATTR
)
364 printk("SMBFS: Using dir ff getattr\n");
367 * Keep the super block locked while we get the root inode.
369 smb_init_root_dirent(&(sb
->u
.smbfs_sb
), &root
);
370 root_inode
= smb_iget(sb
, &root
);
374 sb
->s_root
= d_alloc_root(root_inode
);
382 kfree(sb
->u
.smbfs_sb
.mnt
);
384 kfree(sb
->u
.smbfs_sb
.temp_buf
);
386 smb_vfree(sb
->u
.smbfs_sb
.packet
);
388 printk(KERN_ERR
"smb_read_super: allocation failure\n");
391 printk(KERN_ERR
"SMBFS: need mount version %d\n", SMB_MOUNT_VERSION
);
394 printk("smb_read_super: missing data argument\n");
400 smb_statfs(struct super_block
*sb
, struct statfs
*buf
)
402 smb_proc_dskattr(sb
, buf
);
404 buf
->f_type
= SMB_SUPER_MAGIC
;
405 buf
->f_namelen
= SMB_MAXPATHLEN
;
410 smb_notify_change(struct dentry
*dentry
, struct iattr
*attr
)
412 struct inode
*inode
= dentry
->d_inode
;
413 struct smb_sb_info
*server
= server_from_dentry(dentry
);
414 unsigned int mask
= (S_IFREG
| S_IFDIR
| S_IRWXU
| S_IRWXG
| S_IRWXO
);
415 int error
, changed
, refresh
= 0;
416 struct smb_fattr fattr
;
418 error
= smb_revalidate_inode(dentry
);
422 if ((error
= inode_change_ok(inode
, attr
)) < 0)
426 if ((attr
->ia_valid
& ATTR_UID
) && (attr
->ia_uid
!= server
->mnt
->uid
))
429 if ((attr
->ia_valid
& ATTR_GID
) && (attr
->ia_uid
!= server
->mnt
->gid
))
432 if ((attr
->ia_valid
& ATTR_MODE
) && (attr
->ia_mode
& ~mask
))
435 if ((attr
->ia_valid
& ATTR_SIZE
) != 0)
437 #ifdef SMBFS_DEBUG_VERBOSE
438 printk("smb_notify_change: changing %s/%s, old size=%ld, new size=%ld\n",
439 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
,
440 (long) inode
->i_size
, (long) attr
->ia_size
);
442 error
= smb_open(dentry
, O_WRONLY
);
445 error
= smb_proc_trunc(server
, inode
->u
.smbfs_i
.fileid
,
449 vmtruncate(inode
, attr
->ia_size
);
454 * Initialize the fattr and check for changed fields.
455 * Note: CTIME under SMB is creation time rather than
456 * change time, so we don't attempt to change it.
458 smb_get_inode_attr(inode
, &fattr
);
461 if ((attr
->ia_valid
& ATTR_MTIME
) != 0)
463 fattr
.f_mtime
= attr
->ia_mtime
;
466 if ((attr
->ia_valid
& ATTR_ATIME
) != 0)
468 fattr
.f_atime
= attr
->ia_atime
;
469 /* Earlier protocols don't have an access time */
470 if (server
->opt
.protocol
>= SMB_PROTOCOL_LANMAN2
)
475 error
= smb_proc_settime(dentry
, &fattr
);
482 * Check for mode changes ... we're extremely limited in
483 * what can be set for SMB servers: just the read-only bit.
485 if ((attr
->ia_valid
& ATTR_MODE
) != 0)
487 #ifdef SMBFS_DEBUG_VERBOSE
488 printk("smb_notify_change: %s/%s mode change, old=%x, new=%lx\n",
489 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
, fattr
.f_mode
,attr
->ia_mode
);
492 if (attr
->ia_mode
& S_IWUSR
)
494 if (fattr
.attr
& aRONLY
)
496 fattr
.attr
&= ~aRONLY
;
501 if (!(fattr
.attr
& aRONLY
))
503 fattr
.attr
|= aRONLY
;
509 error
= smb_proc_setattr(dentry
, &fattr
);
519 smb_refresh_inode(dentry
);
523 #ifdef DEBUG_SMB_MALLOC
525 int smb_current_kmalloced
;
526 int smb_current_vmalloced
;
529 static DECLARE_FSTYPE( smb_fs_type
, "smbfs", smb_read_super
, 0);
531 static int __init
init_smb_fs(void)
533 pr_debug("smbfs: init_module called\n");
535 #ifdef DEBUG_SMB_MALLOC
537 smb_current_kmalloced
= 0;
538 smb_current_vmalloced
= 0;
541 return register_filesystem(&smb_fs_type
);
544 static void __exit
exit_smb_fs(void)
546 pr_debug("smbfs: cleanup_module called\n");
547 unregister_filesystem(&smb_fs_type
);
548 #ifdef DEBUG_SMB_MALLOC
549 printk(KERN_DEBUG
"smb_malloced: %d\n", smb_malloced
);
550 printk(KERN_DEBUG
"smb_current_kmalloced: %d\n",smb_current_kmalloced
);
551 printk(KERN_DEBUG
"smb_current_vmalloced: %d\n",smb_current_vmalloced
);
557 module_init(init_smb_fs
)
558 module_exit(exit_smb_fs
)