Fix reported Samba bug.
[linux-2.6/linux-mips.git] / fs / smbfs / inode.c
blobcaa8cc533162f26a740c7118526cca6eac52e4c8
1 /*
2 * inode.c
4 * Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke
5 * Copyright (C) 1997 by Volker Lendecke
7 */
9 #include <linux/module.h>
10 #include <linux/sched.h>
11 #include <linux/kernel.h>
12 #include <linux/mm.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,
43 statfs: smb_statfs,
46 /* FIXME: Look at all inodes whether so that we do not get duplicate
47 * inode numbers. */
49 unsigned long
50 smb_invent_inos(unsigned long n)
52 static unsigned long ino = 2;
54 if (ino + 2*n < ino)
56 /* wrap around */
57 ino = 2;
59 ino += n;
60 return ino;
63 /* We are always generating a new inode here */
64 struct inode *
65 smb_iget(struct super_block *sb, struct smb_fattr *fattr)
67 struct inode *result;
69 pr_debug("smb_iget: %p\n", fattr);
71 result = get_empty_inode();
72 if (!result)
73 return result;
74 result->i_sb = sb;
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);
88 return result;
92 * Copy the inode data to a smb_fattr structure.
94 void
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;
117 else
118 fattr->attr |= aRONLY;
121 static void
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.
154 void
155 smb_invalidate_inodes(struct smb_sb_info *server)
157 #ifdef SMBFS_DEBUG_VERBOSE
158 printk("smb_invalidate_inodes\n");
159 #endif
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.
168 static int
169 smb_refresh_inode(struct dentry *dentry)
171 struct inode *inode = dentry->d_inode;
172 int error;
173 struct smb_fattr fattr;
175 error = smb_proc_getattr(dentry, &fattr);
176 if (!error)
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);
185 else
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);
198 #endif
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);
209 else
210 smb_invalid_dir_cache(inode);
211 error = -EIO;
214 return error;
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;
226 time_t last_time;
227 int error = 0;
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.
234 lock_kernel();
235 if (S_ISREG(inode->i_mode) && smb_is_open(inode))
237 if (inode->u.smbfs_i.access != SMB_O_RDONLY)
238 goto out;
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);
249 #endif
250 goto out;
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);
265 #endif
266 if (!S_ISDIR(inode->i_mode))
267 invalidate_inode_pages(inode);
268 else
269 smb_invalid_dir_cache(inode);
271 out:
272 unlock_kernel();
273 return error;
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.
280 static void
281 smb_delete_inode(struct inode *ino)
283 pr_debug("smb_delete_inode\n");
284 lock_kernel();
285 if (smb_close(ino))
286 printk("smb_delete_inode: could not close inode %ld\n",
287 ino->i_ino);
288 unlock_kernel();
289 clear_inode(ino);
292 static void
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);
306 kfree(server->mnt);
307 kfree(sb->u.smbfs_sb.temp_buf);
308 if (server->packet)
309 smb_vfree(server->packet);
312 struct super_block *
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;
319 if (!raw_data)
320 goto out_no_data;
321 if (((struct smb_mount_data *) raw_data)->version != SMB_MOUNT_VERSION)
322 goto out_wrong_data;
324 sb->s_blocksize = 1024; /* Eh... Is this correct? */
325 sb->s_blocksize_bits = 10;
326 sb->s_magic = SMB_SUPER_MAGIC;
327 sb->s_flags = 0;
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)
339 goto out_no_mem;
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)
344 goto out_no_temp;
346 /* Allocate the mount data structure */
347 mnt = kmalloc(sizeof(struct smb_mount_data), GFP_KERNEL);
348 if (!mnt)
349 goto out_no_mount;
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);
371 if (!root_inode)
372 goto out_no_root;
374 sb->s_root = d_alloc_root(root_inode);
375 if (!sb->s_root)
376 goto out_no_root;
378 return sb;
380 out_no_root:
381 iput(root_inode);
382 kfree(sb->u.smbfs_sb.mnt);
383 out_no_mount:
384 kfree(sb->u.smbfs_sb.temp_buf);
385 out_no_temp:
386 smb_vfree(sb->u.smbfs_sb.packet);
387 out_no_mem:
388 printk(KERN_ERR "smb_read_super: allocation failure\n");
389 goto out_fail;
390 out_wrong_data:
391 printk(KERN_ERR "SMBFS: need mount version %d\n", SMB_MOUNT_VERSION);
392 goto out_fail;
393 out_no_data:
394 printk("smb_read_super: missing data argument\n");
395 out_fail:
396 return NULL;
399 static int
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;
406 return 0;
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);
419 if (error)
420 goto out;
422 if ((error = inode_change_ok(inode, attr)) < 0)
423 goto out;
425 error = -EPERM;
426 if ((attr->ia_valid & ATTR_UID) && (attr->ia_uid != server->mnt->uid))
427 goto out;
429 if ((attr->ia_valid & ATTR_GID) && (attr->ia_uid != server->mnt->gid))
430 goto out;
432 if ((attr->ia_valid & ATTR_MODE) && (attr->ia_mode & ~mask))
433 goto out;
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);
441 #endif
442 error = smb_open(dentry, O_WRONLY);
443 if (error)
444 goto out;
445 error = smb_proc_trunc(server, inode->u.smbfs_i.fileid,
446 attr->ia_size);
447 if (error)
448 goto out;
449 vmtruncate(inode, attr->ia_size);
450 refresh = 1;
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);
460 changed = 0;
461 if ((attr->ia_valid & ATTR_MTIME) != 0)
463 fattr.f_mtime = attr->ia_mtime;
464 changed = 1;
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)
471 changed = 1;
473 if (changed)
475 error = smb_proc_settime(dentry, &fattr);
476 if (error)
477 goto out;
478 refresh = 1;
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);
490 #endif
491 changed = 0;
492 if (attr->ia_mode & S_IWUSR)
494 if (fattr.attr & aRONLY)
496 fattr.attr &= ~aRONLY;
497 changed = 1;
499 } else
501 if (!(fattr.attr & aRONLY))
503 fattr.attr |= aRONLY;
504 changed = 1;
507 if (changed)
509 error = smb_proc_setattr(dentry, &fattr);
510 if (error)
511 goto out;
512 refresh = 1;
515 error = 0;
517 out:
518 if (refresh)
519 smb_refresh_inode(dentry);
520 return error;
523 #ifdef DEBUG_SMB_MALLOC
524 int smb_malloced;
525 int smb_current_kmalloced;
526 int smb_current_vmalloced;
527 #endif
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
536 smb_malloced = 0;
537 smb_current_kmalloced = 0;
538 smb_current_vmalloced = 0;
539 #endif
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);
552 #endif
555 EXPORT_NO_SYMBOLS;
557 module_init(init_smb_fs)
558 module_exit(exit_smb_fs)