?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] mpage_writepages() page locking fix
[linux-2.6/linux-2.6-openrd.git] / fs / hostfs / hostfs_kern.c
bloba88ad2924851109c20f218f0c0f98f4bec1f4684
1 /*
2 * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
3 * Licensed under the GPL
4 *
5 * Ported the filesystem routines to 2.5.
6 * 2003-02-10 Petr Baudis <pasky@ucw.cz>
7 */
8
9 #include <linux/stddef.h>
10 #include <linux/fs.h>
11 #include <linux/version.h>
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/slab.h>
15 #include <linux/pagemap.h>
16 #include <linux/blkdev.h>
17 #include <linux/list.h>
18 #include <linux/root_dev.h>
19 #include <linux/statfs.h>
20 #include <linux/kdev_t.h>
21 #include <asm/uaccess.h>
22 #include "hostfs.h"
23 #include "kern_util.h"
24 #include "kern.h"
25 #include "user_util.h"
26 #include "2_5compat.h"
27 #include "init.h"
28
29 struct hostfs_inode_info {
30 char *host_filename;
31 int fd;
32 int mode;
33 struct inode vfs_inode;
34 };
35
36 static inline struct hostfs_inode_info *HOSTFS_I(struct inode *inode)
37 {
38 return(list_entry(inode, struct hostfs_inode_info, vfs_inode));
39 }
40
41 #define FILE_HOSTFS_I(file) HOSTFS_I((file)->f_dentry->d_inode)
42
43 int hostfs_d_delete(struct dentry *dentry)
44 {
45 return(1);
46 }
47
48 struct dentry_operations hostfs_dentry_ops = {
49 .d_delete = hostfs_d_delete,
50 };
51
52 /* Changed in hostfs_args before the kernel starts running */
53 static char *root_ino = "/";
54 static int append = 0;
55
56 #define HOSTFS_SUPER_MAGIC 0x00c0ffee
57
58 static struct inode_operations hostfs_iops;
59 static struct inode_operations hostfs_dir_iops;
60 static struct address_space_operations hostfs_link_aops;
61
62 #ifndef MODULE
63 static int __init hostfs_args(char *options, int *add)
64 {
65 char *ptr;
66
67 ptr = strchr(options, ',');
68 if(ptr != NULL)
69 *ptr++ = '\0';
70 if(*options != '\0')
71 root_ino = options;
72
73 options = ptr;
74 while(options){
75 ptr = strchr(options, ',');
76 if(ptr != NULL)
77 *ptr++ = '\0';
78 if(*options != '\0'){
79 if(!strcmp(options, "append"))
80 append = 1;
81 else printf("hostfs_args - unsupported option - %s\n",
82 options);
83 }
84 options = ptr;
85 }
86 return(0);
87 }
88
89 __uml_setup("hostfs=", hostfs_args,
90 "hostfs=<root dir>,<flags>,...\n"
91 " This is used to set hostfs parameters. The root directory argument\n"
92 " is used to confine all hostfs mounts to within the specified directory\n"
93 " tree on the host. If this isn't specified, then a user inside UML can\n"
94 " mount anything on the host that's accessible to the user that's running\n"
95 " it.\n"
96 " The only flag currently supported is 'append', which specifies that all\n"
97 " files opened by hostfs will be opened in append mode.\n\n"
98 );
99 #endif
100
101 static char *dentry_name(struct dentry *dentry, int extra)
102 {
103 struct dentry *parent;
104 char *root, *name;
105 int len;
106
107 len = 0;
108 parent = dentry;
109 while(parent->d_parent != parent){
110 len += parent->d_name.len + 1;
111 parent = parent->d_parent;
112 }
113
114 root = HOSTFS_I(parent->d_inode)->host_filename;
115 len += strlen(root);
116 name = kmalloc(len + extra + 1, GFP_KERNEL);
117 if(name == NULL) return(NULL);
118
119 name[len] = '\0';
120 parent = dentry;
121 while(parent->d_parent != parent){
122 len -= parent->d_name.len + 1;
123 name[len] = '/';
124 strncpy(&name[len + 1], parent->d_name.name,
125 parent->d_name.len);
126 parent = parent->d_parent;
127 }
128 strncpy(name, root, strlen(root));
129 return(name);
130 }
131
132 static char *inode_name(struct inode *ino, int extra)
133 {
134 struct dentry *dentry;
135
136 dentry = list_entry(ino->i_dentry.next, struct dentry, d_alias);
137 return(dentry_name(dentry, extra));
138 }
139
140 static int read_name(struct inode *ino, char *name)
141 {
142 /* The non-int inode fields are copied into ints by stat_file and
143 * then copied into the inode because passing the actual pointers
144 * in and having them treated as int * breaks on big-endian machines
145 */
146 int err;
147 int i_mode, i_nlink, i_blksize;
148 unsigned long long i_size;
149 unsigned long long i_ino;
150 unsigned long long i_blocks;
151
152 err = stat_file(name, &i_ino, &i_mode, &i_nlink, &ino->i_uid,
153 &ino->i_gid, &i_size, &ino->i_atime, &ino->i_mtime,
154 &ino->i_ctime, &i_blksize, &i_blocks);
155 if(err)
156 return(err);
157
158 ino->i_ino = i_ino;
159 ino->i_mode = i_mode;
160 ino->i_nlink = i_nlink;
161 ino->i_size = i_size;
162 ino->i_blksize = i_blksize;
163 ino->i_blocks = i_blocks;
164 if((ino->i_sb->s_dev == ROOT_DEV) && (ino->i_uid == getuid()))
165 ino->i_uid = 0;
166 return(0);
167 }
168
169 static char *follow_link(char *link)
170 {
171 int len, n;
172 char *name, *resolved, *end;
173
174 len = 64;
175 while(1){
176 n = -ENOMEM;
177 name = kmalloc(len, GFP_KERNEL);
178 if(name == NULL)
179 goto out;
180
181 n = do_readlink(link, name, len);
182 if(n < len)
183 break;
184 len *= 2;
185 kfree(name);
186 }
187 if(n < 0)
188 goto out_free;
189
190 if(*name == '/')
191 return(name);
192
193 end = strrchr(link, '/');
194 if(end == NULL)
195 return(name);
196
197 *(end + 1) = '\0';
198 len = strlen(link) + strlen(name) + 1;
199
200 resolved = kmalloc(len, GFP_KERNEL);
201 if(resolved == NULL){
202 n = -ENOMEM;
203 goto out_free;
204 }
205
206 sprintf(resolved, "%s%s", link, name);
207 kfree(name);
208 kfree(link);
209 return(resolved);
210
211 out_free:
212 kfree(name);
213 out:
214 return(ERR_PTR(n));
215 }
216
217 static int read_inode(struct inode *ino)
218 {
219 char *name;
220 int err = 0;
221
222 /* Unfortunately, we are called from iget() when we don't have a dentry
223 * allocated yet.
224 */
225 if(list_empty(&ino->i_dentry))
226 goto out;
227
228 err = -ENOMEM;
229 name = inode_name(ino, 0);
230 if(name == NULL)
231 goto out;
232
233 if(file_type(name, NULL, NULL) == OS_TYPE_SYMLINK){
234 name = follow_link(name);
235 if(IS_ERR(name)){
236 err = PTR_ERR(name);
237 goto out;
238 }
239 }
240
241 err = read_name(ino, name);
242 kfree(name);
243 out:
244 return(err);
245 }
246
247 int hostfs_statfs(struct super_block *sb, struct kstatfs *sf)
248 {
249 /* do_statfs uses struct statfs64 internally, but the linux kernel
250 * struct statfs still has 32-bit versions for most of these fields,
251 * so we convert them here
252 */
253 int err;
254 long long f_blocks;
255 long long f_bfree;
256 long long f_bavail;
257 long long f_files;
258 long long f_ffree;
259
260 err = do_statfs(HOSTFS_I(sb->s_root->d_inode)->host_filename,
261 &sf->f_bsize, &f_blocks, &f_bfree, &f_bavail, &f_files,
262 &f_ffree, &sf->f_fsid, sizeof(sf->f_fsid),
263 &sf->f_namelen, sf->f_spare);
264 if(err) return(err);
265 sf->f_blocks = f_blocks;
266 sf->f_bfree = f_bfree;
267 sf->f_bavail = f_bavail;
268 sf->f_files = f_files;
269 sf->f_ffree = f_ffree;
270 sf->f_type = HOSTFS_SUPER_MAGIC;
271 return(0);
272 }
273
274 static struct inode *hostfs_alloc_inode(struct super_block *sb)
275 {
276 struct hostfs_inode_info *hi;
277
278 hi = kmalloc(sizeof(*hi), GFP_KERNEL);
279 if(hi == NULL)
280 return(NULL);
281
282 *hi = ((struct hostfs_inode_info) { .host_filename = NULL,
283 .fd = -1,
284 .mode = 0 });
285 inode_init_once(&hi->vfs_inode);
286 return(&hi->vfs_inode);
287 }
288
289 static void hostfs_delete_inode(struct inode *inode)
290 {
291 if(HOSTFS_I(inode)->fd != -1) {
292 close_file(&HOSTFS_I(inode)->fd);
293 HOSTFS_I(inode)->fd = -1;
294 }
295 clear_inode(inode);
296 }
297
298 static void hostfs_destroy_inode(struct inode *inode)
299 {
300 if(HOSTFS_I(inode)->host_filename)
301 kfree(HOSTFS_I(inode)->host_filename);
302
303 /*XXX: This should not happen, probably. The check is here for
304 * additional safety.*/
305 if(HOSTFS_I(inode)->fd != -1) {
306 close_file(&HOSTFS_I(inode)->fd);
307 printk(KERN_DEBUG "Closing host fd in .destroy_inode\n");
308 }
309
310 kfree(HOSTFS_I(inode));
311 }
312
313 static void hostfs_read_inode(struct inode *inode)
314 {
315 read_inode(inode);
316 }
317
318 static struct super_operations hostfs_sbops = {
319 .alloc_inode = hostfs_alloc_inode,
320 .drop_inode = generic_delete_inode,
321 .delete_inode = hostfs_delete_inode,
322 .destroy_inode = hostfs_destroy_inode,
323 .read_inode = hostfs_read_inode,
324 .statfs = hostfs_statfs,
325 };
326
327 int hostfs_readdir(struct file *file, void *ent, filldir_t filldir)
328 {
329 void *dir;
330 char *name;
331 unsigned long long next, ino;
332 int error, len;
333
334 name = dentry_name(file->f_dentry, 0);
335 if(name == NULL) return(-ENOMEM);
336 dir = open_dir(name, &error);
337 kfree(name);
338 if(dir == NULL) return(-error);
339 next = file->f_pos;
340 while((name = read_dir(dir, &next, &ino, &len)) != NULL){
341 error = (*filldir)(ent, name, len, file->f_pos,
342 ino, DT_UNKNOWN);
343 if(error) break;
344 file->f_pos = next;
345 }
346 close_dir(dir);
347 return(0);
348 }
349
350 int hostfs_file_open(struct inode *ino, struct file *file)
351 {
352 char *name;
353 int mode = 0, r = 0, w = 0, fd;
354
355 mode = file->f_mode & (FMODE_READ | FMODE_WRITE);
356 if((mode & HOSTFS_I(ino)->mode) == mode)
357 return(0);
358
359 /* The file may already have been opened, but with the wrong access,
360 * so this resets things and reopens the file with the new access.
361 */
362 if(HOSTFS_I(ino)->fd != -1){
363 close_file(&HOSTFS_I(ino)->fd);
364 HOSTFS_I(ino)->fd = -1;
365 }
366
367 HOSTFS_I(ino)->mode |= mode;
368 if(HOSTFS_I(ino)->mode & FMODE_READ)
369 r = 1;
370 if(HOSTFS_I(ino)->mode & FMODE_WRITE)
371 w = 1;
372 if(w)
373 r = 1;
374
375 name = dentry_name(file->f_dentry, 0);
376 if(name == NULL)
377 return(-ENOMEM);
378
379 fd = open_file(name, r, w, append);
380 kfree(name);
381 if(fd < 0) return(fd);
382 FILE_HOSTFS_I(file)->fd = fd;
383
384 return(0);
385 }
386
387 int hostfs_fsync(struct file *file, struct dentry *dentry, int datasync)
388 {
389 return(0);
390 }
391
392 static struct file_operations hostfs_file_fops = {
393 .llseek = generic_file_llseek,
394 .read = generic_file_read,
395 .sendfile = generic_file_sendfile,
396 .aio_read = generic_file_aio_read,
397 .aio_write = generic_file_aio_write,
398 .readv = generic_file_readv,
399 .writev = generic_file_writev,
400 .write = generic_file_write,
401 .mmap = generic_file_mmap,
402 .open = hostfs_file_open,
403 .release = NULL,
404 .fsync = hostfs_fsync,
405 };
406
407 static struct file_operations hostfs_dir_fops = {
408 .llseek = generic_file_llseek,
409 .readdir = hostfs_readdir,
410 .read = generic_read_dir,
411 };
412
413 int hostfs_writepage(struct page *page, struct writeback_control *wbc)
414 {
415 struct address_space *mapping = page->mapping;
416 struct inode *inode = mapping->host;
417 char *buffer;
418 unsigned long long base;
419 int count = PAGE_CACHE_SIZE;
420 int end_index = inode->i_size >> PAGE_CACHE_SHIFT;
421 int err;
422
423 if (page->index >= end_index)
424 count = inode->i_size & (PAGE_CACHE_SIZE-1);
425
426 buffer = kmap(page);
427 base = ((unsigned long long) page->index) << PAGE_CACHE_SHIFT;
428
429 err = write_file(HOSTFS_I(inode)->fd, &base, buffer, count);
430 if(err != count){
431 ClearPageUptodate(page);
432 goto out;
433 }
434
435 if (base > inode->i_size)
436 inode->i_size = base;
437
438 if (PageError(page))
439 ClearPageError(page);
440 err = 0;
441
442 out:
443 kunmap(page);
444
445 unlock_page(page);
446 return err;
447 }
448
449 int hostfs_readpage(struct file *file, struct page *page)
450 {
451 char *buffer;
452 long long start;
453 int err = 0;
454
455 start = (long long) page->index << PAGE_CACHE_SHIFT;
456 buffer = kmap(page);
457 err = read_file(FILE_HOSTFS_I(file)->fd, &start, buffer,
458 PAGE_CACHE_SIZE);
459 if(err < 0) goto out;
460
461 memset(&buffer[err], 0, PAGE_CACHE_SIZE - err);
462
463 flush_dcache_page(page);
464 SetPageUptodate(page);
465 if (PageError(page)) ClearPageError(page);
466 err = 0;
467 out:
468 kunmap(page);
469 unlock_page(page);
470 return(err);
471 }
472
473 int hostfs_prepare_write(struct file *file, struct page *page,
474 unsigned int from, unsigned int to)
475 {
476 char *buffer;
477 long long start, tmp;
478 int err;
479
480 start = (long long) page->index << PAGE_CACHE_SHIFT;
481 buffer = kmap(page);
482 if(from != 0){
483 tmp = start;
484 err = read_file(FILE_HOSTFS_I(file)->fd, &tmp, buffer,
485 from);
486 if(err < 0) goto out;
487 }
488 if(to != PAGE_CACHE_SIZE){
489 start += to;
490 err = read_file(FILE_HOSTFS_I(file)->fd, &start, buffer + to,
491 PAGE_CACHE_SIZE - to);
492 if(err < 0) goto out;
493 }
494 err = 0;
495 out:
496 kunmap(page);
497 return(err);
498 }
499
500 int hostfs_commit_write(struct file *file, struct page *page, unsigned from,
501 unsigned to)
502 {
503 struct address_space *mapping = page->mapping;
504 struct inode *inode = mapping->host;
505 char *buffer;
506 long long start;
507 int err = 0;
508
509 start = (long long) (page->index << PAGE_CACHE_SHIFT) + from;
510 buffer = kmap(page);
511 err = write_file(FILE_HOSTFS_I(file)->fd, &start, buffer + from,
512 to - from);
513 if(err > 0) err = 0;
514 if(!err && (start > inode->i_size))
515 inode->i_size = start;
516
517 kunmap(page);
518 return(err);
519 }
520
521 static struct address_space_operations hostfs_aops = {
522 .writepage = hostfs_writepage,
523 .readpage = hostfs_readpage,
524 /* .set_page_dirty = __set_page_dirty_nobuffers, */
525 .prepare_write = hostfs_prepare_write,
526 .commit_write = hostfs_commit_write
527 };
528
529 static int init_inode(struct inode *inode, struct dentry *dentry)
530 {
531 char *name;
532 int type, err = -ENOMEM;
533 int maj, min;
534 dev_t rdev = 0;
535
536 if(dentry){
537 name = dentry_name(dentry, 0);
538 if(name == NULL)
539 goto out;
540 type = file_type(name, &maj, &min);
541 /*Reencode maj and min with the kernel encoding.*/
542 rdev = MKDEV(maj, min);
543 kfree(name);
544 }
545 else type = OS_TYPE_DIR;
546
547 err = 0;
548 if(type == OS_TYPE_SYMLINK)
549 inode->i_op = &page_symlink_inode_operations;
550 else if(type == OS_TYPE_DIR)
551 inode->i_op = &hostfs_dir_iops;
552 else inode->i_op = &hostfs_iops;
553
554 if(type == OS_TYPE_DIR) inode->i_fop = &hostfs_dir_fops;
555 else inode->i_fop = &hostfs_file_fops;
556
557 if(type == OS_TYPE_SYMLINK)
558 inode->i_mapping->a_ops = &hostfs_link_aops;
559 else inode->i_mapping->a_ops = &hostfs_aops;
560
561 switch (type) {
562 case OS_TYPE_CHARDEV:
563 init_special_inode(inode, S_IFCHR, rdev);
564 break;
565 case OS_TYPE_BLOCKDEV:
566 init_special_inode(inode, S_IFBLK, rdev);
567 break;
568 case OS_TYPE_FIFO:
569 init_special_inode(inode, S_IFIFO, 0);
570 break;
571 case OS_TYPE_SOCK:
572 init_special_inode(inode, S_IFSOCK, 0);
573 break;
574 }
575 out:
576 return(err);
577 }
578
579 int hostfs_create(struct inode *dir, struct dentry *dentry, int mode,
580 struct nameidata *nd)
581 {
582 struct inode *inode;
583 char *name;
584 int error, fd;
585
586 error = -ENOMEM;
587 inode = iget(dir->i_sb, 0);
588 if(inode == NULL) goto out;
589
590 error = init_inode(inode, dentry);
591 if(error)
592 goto out_put;
593
594 error = -ENOMEM;
595 name = dentry_name(dentry, 0);
596 if(name == NULL)
597 goto out_put;
598
599 fd = file_create(name,
600 mode & S_IRUSR, mode & S_IWUSR, mode & S_IXUSR,
601 mode & S_IRGRP, mode & S_IWGRP, mode & S_IXGRP,
602 mode & S_IROTH, mode & S_IWOTH, mode & S_IXOTH);
603 if(fd < 0)
604 error = fd;
605 else error = read_name(inode, name);
606
607 kfree(name);
608 if(error)
609 goto out_put;
610
611 HOSTFS_I(inode)->fd = fd;
612 HOSTFS_I(inode)->mode = FMODE_READ | FMODE_WRITE;
613 d_instantiate(dentry, inode);
614 return(0);
615
616 out_put:
617 iput(inode);
618 out:
619 return(error);
620 }
621
622 struct dentry *hostfs_lookup(struct inode *ino, struct dentry *dentry,
623 struct nameidata *nd)
624 {
625 struct inode *inode;
626 char *name;
627 int err;
628
629 err = -ENOMEM;
630 inode = iget(ino->i_sb, 0);
631 if(inode == NULL)
632 goto out;
633
634 err = init_inode(inode, dentry);
635 if(err)
636 goto out_put;
637
638 err = -ENOMEM;
639 name = dentry_name(dentry, 0);
640 if(name == NULL)
641 goto out_put;
642
643 err = read_name(inode, name);
644 kfree(name);
645 if(err == -ENOENT){
646 iput(inode);
647 inode = NULL;
648 }
649 else if(err)
650 goto out_put;
651
652 d_add(dentry, inode);
653 dentry->d_op = &hostfs_dentry_ops;
654 return(NULL);
655
656 out_put:
657 iput(inode);
658 out:
659 return(ERR_PTR(err));
660 }
661
662 static char *inode_dentry_name(struct inode *ino, struct dentry *dentry)
663 {
664 char *file;
665 int len;
666
667 file = inode_name(ino, dentry->d_name.len + 1);
668 if(file == NULL) return(NULL);
669 strcat(file, "/");
670 len = strlen(file);
671 strncat(file, dentry->d_name.name, dentry->d_name.len);
672 file[len + dentry->d_name.len] = '\0';
673 return(file);
674 }
675
676 int hostfs_link(struct dentry *to, struct inode *ino, struct dentry *from)
677 {
678 char *from_name, *to_name;
679 int err;
680
681 if((from_name = inode_dentry_name(ino, from)) == NULL)
682 return(-ENOMEM);
683 to_name = dentry_name(to, 0);
684 if(to_name == NULL){
685 kfree(from_name);
686 return(-ENOMEM);
687 }
688 err = link_file(to_name, from_name);
689 kfree(from_name);
690 kfree(to_name);
691 return(err);
692 }
693
694 int hostfs_unlink(struct inode *ino, struct dentry *dentry)
695 {
696 char *file;
697 int err;
698
699 if((file = inode_dentry_name(ino, dentry)) == NULL) return(-ENOMEM);
700 if(append)
701 return(-EPERM);
702
703 err = unlink_file(file);
704 kfree(file);
705 return(err);
706 }
707
708 int hostfs_symlink(struct inode *ino, struct dentry *dentry, const char *to)
709 {
710 char *file;
711 int err;
712
713 if((file = inode_dentry_name(ino, dentry)) == NULL) return(-ENOMEM);
714 err = make_symlink(file, to);
715 kfree(file);
716 return(err);
717 }
718
719 int hostfs_mkdir(struct inode *ino, struct dentry *dentry, int mode)
720 {
721 char *file;
722 int err;
723
724 if((file = inode_dentry_name(ino, dentry)) == NULL) return(-ENOMEM);
725 err = do_mkdir(file, mode);
726 kfree(file);
727 return(err);
728 }
729
730 int hostfs_rmdir(struct inode *ino, struct dentry *dentry)
731 {
732 char *file;
733 int err;
734
735 if((file = inode_dentry_name(ino, dentry)) == NULL) return(-ENOMEM);
736 err = do_rmdir(file);
737 kfree(file);
738 return(err);
739 }
740
741 int hostfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
742 {
743 struct inode *inode;
744 char *name;
745 int err = -ENOMEM;
746
747 inode = iget(dir->i_sb, 0);
748 if(inode == NULL)
749 goto out;
750
751 err = init_inode(inode, dentry);
752 if(err)
753 goto out_put;
754
755 err = -ENOMEM;
756 name = dentry_name(dentry, 0);
757 if(name == NULL)
758 goto out_put;
759
760 init_special_inode(inode, mode, dev);
761 err = do_mknod(name, mode, dev);
762 if(err)
763 goto out_free;
764
765 err = read_name(inode, name);
766 kfree(name);
767 if(err)
768 goto out_put;
769
770 d_instantiate(dentry, inode);
771 return(0);
772
773 out_free:
774 kfree(name);
775 out_put:
776 iput(inode);
777 out:
778 return(err);
779 }
780
781 int hostfs_rename(struct inode *from_ino, struct dentry *from,
782 struct inode *to_ino, struct dentry *to)
783 {
784 char *from_name, *to_name;
785 int err;
786
787 if((from_name = inode_dentry_name(from_ino, from)) == NULL)
788 return(-ENOMEM);
789 if((to_name = inode_dentry_name(to_ino, to)) == NULL){
790 kfree(from_name);
791 return(-ENOMEM);
792 }
793 err = rename_file(from_name, to_name);
794 kfree(from_name);
795 kfree(to_name);
796 return(err);
797 }
798
799 void hostfs_truncate(struct inode *ino)
800 {
801 not_implemented();
802 }
803
804 int hostfs_permission(struct inode *ino, int desired, struct nameidata *nd)
805 {
806 char *name;
807 int r = 0, w = 0, x = 0, err;
808
809 if (desired & MAY_READ) r = 1;
810 if (desired & MAY_WRITE) w = 1;
811 if (desired & MAY_EXEC) x = 1;
812 name = inode_name(ino, 0);
813 if (name == NULL) return(-ENOMEM);
814
815 if (S_ISCHR(ino->i_mode) || S_ISBLK(ino->i_mode) ||
816 S_ISFIFO(ino->i_mode) || S_ISSOCK(ino->i_mode))
817 err = 0;
818 else
819 err = access_file(name, r, w, x);
820 kfree(name);
821 if(!err)
822 err = generic_permission(ino, desired, NULL);
823 return err;
824 }
825
826 int hostfs_setattr(struct dentry *dentry, struct iattr *attr)
827 {
828 struct hostfs_iattr attrs;
829 char *name;
830 int err;
831
832 err = inode_change_ok(dentry->d_inode, attr);
833 if (err)
834 return err;
835
836 if(append)
837 attr->ia_valid &= ~ATTR_SIZE;
838
839 attrs.ia_valid = 0;
840 if(attr->ia_valid & ATTR_MODE){
841 attrs.ia_valid |= HOSTFS_ATTR_MODE;
842 attrs.ia_mode = attr->ia_mode;
843 }
844 if(attr->ia_valid & ATTR_UID){
845 if((dentry->d_inode->i_sb->s_dev == ROOT_DEV) &&
846 (attr->ia_uid == 0))
847 attr->ia_uid = getuid();
848 attrs.ia_valid |= HOSTFS_ATTR_UID;
849 attrs.ia_uid = attr->ia_uid;
850 }
851 if(attr->ia_valid & ATTR_GID){
852 if((dentry->d_inode->i_sb->s_dev == ROOT_DEV) &&
853 (attr->ia_gid == 0))
854 attr->ia_gid = getgid();
855 attrs.ia_valid |= HOSTFS_ATTR_GID;
856 attrs.ia_gid = attr->ia_gid;
857 }
858 if(attr->ia_valid & ATTR_SIZE){
859 attrs.ia_valid |= HOSTFS_ATTR_SIZE;
860 attrs.ia_size = attr->ia_size;
861 }
862 if(attr->ia_valid & ATTR_ATIME){
863 attrs.ia_valid |= HOSTFS_ATTR_ATIME;
864 attrs.ia_atime = attr->ia_atime;
865 }
866 if(attr->ia_valid & ATTR_MTIME){
867 attrs.ia_valid |= HOSTFS_ATTR_MTIME;
868 attrs.ia_mtime = attr->ia_mtime;
869 }
870 if(attr->ia_valid & ATTR_CTIME){
871 attrs.ia_valid |= HOSTFS_ATTR_CTIME;
872 attrs.ia_ctime = attr->ia_ctime;
873 }
874 if(attr->ia_valid & ATTR_ATIME_SET){
875 attrs.ia_valid |= HOSTFS_ATTR_ATIME_SET;
876 }
877 if(attr->ia_valid & ATTR_MTIME_SET){
878 attrs.ia_valid |= HOSTFS_ATTR_MTIME_SET;
879 }
880 name = dentry_name(dentry, 0);
881 if(name == NULL) return(-ENOMEM);
882 err = set_attr(name, &attrs);
883 kfree(name);
884 if(err)
885 return(err);
886
887 return(inode_setattr(dentry->d_inode, attr));
888 }
889
890 int hostfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
891 struct kstat *stat)
892 {
893 generic_fillattr(dentry->d_inode, stat);
894 return(0);
895 }
896
897 static struct inode_operations hostfs_iops = {
898 .create = hostfs_create,
899 .link = hostfs_link,
900 .unlink = hostfs_unlink,
901 .symlink = hostfs_symlink,
902 .mkdir = hostfs_mkdir,
903 .rmdir = hostfs_rmdir,
904 .mknod = hostfs_mknod,
905 .rename = hostfs_rename,
906 .truncate = hostfs_truncate,
907 .permission = hostfs_permission,
908 .setattr = hostfs_setattr,
909 .getattr = hostfs_getattr,
910 };
911
912 static struct inode_operations hostfs_dir_iops = {
913 .create = hostfs_create,
914 .lookup = hostfs_lookup,
915 .link = hostfs_link,
916 .unlink = hostfs_unlink,
917 .symlink = hostfs_symlink,
918 .mkdir = hostfs_mkdir,
919 .rmdir = hostfs_rmdir,
920 .mknod = hostfs_mknod,
921 .rename = hostfs_rename,
922 .truncate = hostfs_truncate,
923 .permission = hostfs_permission,
924 .setattr = hostfs_setattr,
925 .getattr = hostfs_getattr,
926 };
927
928 int hostfs_link_readpage(struct file *file, struct page *page)
929 {
930 char *buffer, *name;
931 long long start;
932 int err;
933
934 start = page->index << PAGE_CACHE_SHIFT;
935 buffer = kmap(page);
936 name = inode_name(page->mapping->host, 0);
937 if(name == NULL) return(-ENOMEM);
938 err = do_readlink(name, buffer, PAGE_CACHE_SIZE);
939 kfree(name);
940 if(err == PAGE_CACHE_SIZE)
941 err = -E2BIG;
942 else if(err > 0){
943 flush_dcache_page(page);
944 SetPageUptodate(page);
945 if (PageError(page)) ClearPageError(page);
946 err = 0;
947 }
948 kunmap(page);
949 unlock_page(page);
950 return(err);
951 }
952
953 static struct address_space_operations hostfs_link_aops = {
954 .readpage = hostfs_link_readpage,
955 };
956
957 static int hostfs_fill_sb_common(struct super_block *sb, void *d, int silent)
958 {
959 struct inode *root_inode;
960 char *name, *data = d;
961 int err;
962
963 sb->s_blocksize = 1024;
964 sb->s_blocksize_bits = 10;
965 sb->s_magic = HOSTFS_SUPER_MAGIC;
966 sb->s_op = &hostfs_sbops;
967
968 if((data == NULL) || (*data == '\0'))
969 data = root_ino;
970
971 err = -ENOMEM;
972 name = kmalloc(strlen(data) + 1, GFP_KERNEL);
973 if(name == NULL)
974 goto out;
975
976 strcpy(name, data);
977
978 root_inode = iget(sb, 0);
979 if(root_inode == NULL)
980 goto out_free;
981
982 err = init_inode(root_inode, NULL);
983 if(err)
984 goto out_put;
985
986 HOSTFS_I(root_inode)->host_filename = name;
987
988 err = -ENOMEM;
989 sb->s_root = d_alloc_root(root_inode);
990 if(sb->s_root == NULL)
991 goto out_put;
992
993 err = read_inode(root_inode);
994 if(err)
995 goto out_put;
996
997 return(0);
998
999 out_put:
1000 iput(root_inode);
1001 out_free:
1002 kfree(name);
1003 out:
1004 return(err);
1005 }
1006
1007 static struct super_block *hostfs_read_sb(struct file_system_type *type,
1008 int flags, const char *dev_name,
1009 void *data)
1010 {
1011 return(get_sb_nodev(type, flags, data, hostfs_fill_sb_common));
1012 }
1013
1014 static struct file_system_type hostfs_type = {
1015 .owner = THIS_MODULE,
1016 .name = "hostfs",
1017 .get_sb = hostfs_read_sb,
1018 .kill_sb = kill_anon_super,
1019 .fs_flags = 0,
1020 };
1021
1022 static int __init init_hostfs(void)
1023 {
1024 return(register_filesystem(&hostfs_type));
1025 }
1026
1027 static void __exit exit_hostfs(void)
1028 {
1029 unregister_filesystem(&hostfs_type);
1030 }
1031
1032 module_init(init_hostfs)
1033 module_exit(exit_hostfs)
1034 MODULE_LICENSE("GPL");
1035
1036 /*
1037 * Overrides for Emacs so that we follow Linus's tabbing style.
1038 * Emacs will notice this stuff at the end of the file and automatically
1039 * adjust the settings for this buffer only. This must remain at the end
1040 * of the file.
1041 * ---------------------------------------------------------------------------
1042 * Local variables:
1043 * c-file-style: "linux"
1044 * End:
1045 */
linux 2.6 git repository for openrd