projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[amazon] move files to correct position
[openwrt.git] / target / linux / generic-2.4 / patches / 231-mini_fo.patch
1 --- a/fs/Config.in
2 +++ b/fs/Config.in
3 @@ -77,6 +77,7 @@ dep_mbool ' JFS debugging' CONFIG_JFS_D
4 dep_mbool ' JFS statistics' CONFIG_JFS_STATISTICS $CONFIG_JFS_FS
5
6 tristate 'Minix fs support' CONFIG_MINIX_FS
7 +tristate 'mini_fo filesystem overlay' CONFIG_MINI_FO
8
9 tristate 'FreeVxFS file system support (VERITAS VxFS(TM) compatible)' CONFIG_VXFS_FS
10 tristate 'NTFS file system support (read only)' CONFIG_NTFS_FS
11 --- a/fs/Makefile
12 +++ b/fs/Makefile
13 @@ -31,6 +31,7 @@ subdir-$(CONFIG_RAMFS) += ramfs
14 subdir-$(CONFIG_CODA_FS) += coda
15 subdir-$(CONFIG_INTERMEZZO_FS) += intermezzo
16 subdir-$(CONFIG_MINIX_FS) += minix
17 +subdir-$(CONFIG_MINI_FO) += mini_fo
18 subdir-$(CONFIG_FAT_FS) += fat
19 subdir-$(CONFIG_UMSDOS_FS) += umsdos
20 subdir-$(CONFIG_MSDOS_FS) += msdos
21 --- /dev/null
22 +++ b/fs/mini_fo/aux.c
23 @@ -0,0 +1,580 @@
24 +/*
25 + * Copyright (c) 1997-2003 Erez Zadok
26 + * Copyright (c) 2001-2003 Stony Brook University
27 + *
28 + * For specific licensing information, see the COPYING file distributed with
29 + * this package, or get one from ftp://ftp.filesystems.org/pub/fist/COPYING.
30 + *
31 + * This Copyright notice must be kept intact and distributed with all
32 + * fistgen sources INCLUDING sources generated by fistgen.
33 + */
34 +/*
35 + * Copyright (C) 2004, 2005 Markus Klotzbuecher <mk@creamnet.de>
36 + *
37 + * This program is free software; you can redistribute it and/or
38 + * modify it under the terms of the GNU General Public License
39 + * as published by the Free Software Foundation; either version
40 + * 2 of the License, or (at your option) any later version.
41 + */
42 +/*
43 + * $Id$
44 + */
45 +
46 +#ifdef HAVE_CONFIG_H
47 +# include <config.h>
48 +#endif
49 +
50 +#include "fist.h"
51 +#include "mini_fo.h"
52 +
53 +/* check if file exists in storage */
54 +int exists_in_storage(dentry_t *dentry)
55 +{
56 + check_mini_fo_dentry(dentry);
57 + if(dtost(dentry) == MODIFIED || dtost(dentry) == CREATED || dtost(dentry) == DEL_REWRITTEN)
58 + return 1;
59 + return 0;
60 +}
61 +
62 +/* check if dentry is in an existing state */
63 +int is_mini_fo_existant(dentry_t *dentry)
64 +{
65 + check_mini_fo_dentry(dentry);
66 +
67 + if(dtost(dentry) == DELETED || dtost(dentry) == NON_EXISTANT)
68 + return 0;
69 + else
70 + return 1;
71 +}
72 +
73 +/*
74 + * This function will create a negative storage dentry for
75 + * dentry, what is required for many create like options.
76 + * It will create the storage structure if necessary.
77 + */
78 +int get_neg_sto_dentry(dentry_t *dentry)
79 +{
80 + int err = 0;
81 + unsigned int len;
82 + const unsigned char *name;
83 +
84 + if(!dentry ||
85 + !dtopd(dentry) ||
86 + !(dtost(dentry) == UNMODIFIED ||
87 + dtost(dentry) == NON_EXISTANT ||
88 + dtost(dentry) == DELETED)) {
89 + printk(KERN_CRIT "mini_fo: get_neg_sto_dentry: invalid dentry passed.\n");
90 + err = -1;
91 + goto out;
92 + }
93 + /* Have we got a neg. dentry already? */
94 + if(dtohd2(dentry)) {
95 + err = 0;
96 + goto out;
97 + }
98 + if(dtost(dentry->d_parent) == UNMODIFIED) {
99 + /* build sto struct */
100 + err = build_sto_structure(dentry->d_parent->d_parent, dentry->d_parent);
101 + if(err ||
102 + dtost(dentry->d_parent) != MODIFIED) {
103 + printk(KERN_CRIT "mini_fo: get_neg_sto_dentry: ERROR building sto structure.\n");
104 + err = -1;
105 + goto out;
106 + }
107 + }
108 +
109 + len = dentry->d_name.len;
110 + name = dentry->d_name.name;
111 +
112 + dtohd2(dentry) =
113 + lookup_one_len(name, dtohd2(dentry->d_parent), len);
114 +
115 + out:
116 + return err;
117 +}
118 +
119 +int check_mini_fo_dentry(dentry_t *dentry)
120 +{
121 + ASSERT(dentry != NULL);
122 + ASSERT(dtopd(dentry) != NULL);
123 + ASSERT((dtohd(dentry) != NULL) || (dtohd2(dentry) != NULL));
124 +
125 +/* if(dtost(dentry) == MODIFIED) { */
126 +/* ASSERT(dentry->d_inode != NULL); */
127 +/* ASSERT(dtohd(dentry) != NULL); */
128 +/* ASSERT(dtohd(dentry)->d_inode != NULL); */
129 +/* ASSERT(dtohd2(dentry) != NULL); */
130 +/* ASSERT(dtohd2(dentry)->d_inode != NULL); */
131 +/* } */
132 +/* else if(dtost(dentry) == UNMODIFIED) { */
133 +/* ASSERT(dentry->d_inode != NULL); */
134 +/* ASSERT( */
135 +/* } */
136 + return 0;
137 +}
138 +
139 +int check_mini_fo_file(file_t *file)
140 +{
141 + ASSERT(file != NULL);
142 + ASSERT(ftopd(file) != NULL);
143 + ASSERT(file->f_dentry != NULL);
144 +
145 + /* violent checking, check depending of state and type
146 + * if(S_ISDIR(file->f_dentry->d_inode->i_mode)) {}
147 + */
148 + ASSERT((ftohf(file) != NULL) || (ftohf2(file) != NULL));
149 + return 0;
150 +}
151 +
152 +int check_mini_fo_inode(inode_t *inode)
153 +{
154 + ASSERT(inode != NULL);
155 + ASSERT(itopd(inode) != NULL);
156 + ASSERT((itohi(inode) != NULL) || (itohi2(inode) != NULL));
157 + return 0;
158 +}
159 +
160 +/*
161 + * will walk a base path as provided by get_mini_fo_bpath and return
162 + * the (hopefully ;-) ) positive dentry of the renamed base dir.
163 + *
164 + * This does some work of path_init.
165 + */
166 +dentry_t *bpath_walk(super_block_t *sb, char *bpath)
167 +{
168 + int err;
169 + struct nameidata nd;
170 +
171 + /* be paranoid */
172 + if(!bpath || bpath[0] != '/') {
173 + printk(KERN_CRIT "mini_fo: bpath_walk: Invalid string.\n");
174 + return NULL;
175 + }
176 + if(!sb || !stopd(sb)) {
177 + printk(KERN_CRIT "mini_fo: bpath_walk: Invalid sb.\n");
178 + return NULL;
179 + }
180 +
181 + /* setup nd as path_init does */
182 + nd.last_type = LAST_ROOT; /* if there are only slashes... */
183 + nd.flags = LOOKUP_FOLLOW;
184 + /* fix this: how do I reach this lock?
185 + * read_lock(&current->fs->lock); */
186 + nd.mnt = mntget(stopd(sb)->hidden_mnt);
187 + nd.dentry = dget(stopd(sb)->base_dir_dentry);
188 + /* read_unlock(&current->fs->lock); */
189 +
190 + err = path_walk(bpath+1, &nd);
191 +
192 + /* validate */
193 + if (err || !nd.dentry || !nd.dentry->d_inode) {
194 + printk(KERN_CRIT "mini_fo: bpath_walk: path_walk failed.\n");
195 + return NULL;
196 + }
197 + return nd.dentry;
198 +}
199 +
200 +
201 +/* returns the full path of the basefile incl. its name */
202 +int get_mini_fo_bpath(dentry_t *dentry, char **bpath, int *bpath_len)
203 +{
204 + char *buf_walker;
205 + int len = 0;
206 + dentry_t *sky_walker;
207 +
208 + if(!dentry || !dtohd(dentry)) {
209 + printk(KERN_CRIT "mini_fo: get_mini_fo_bpath: invalid dentry passed.\n");
210 + return -1;
211 + }
212 + sky_walker = dtohd(dentry);
213 +
214 + do {
215 + len += sky_walker->d_name.len + 1 ; /* 1 for '/' */
216 + sky_walker = sky_walker->d_parent;
217 + } while(sky_walker != stopd(dentry->d_inode->i_sb)->base_dir_dentry);
218 +
219 + /* 1 to oil the loop */
220 + *bpath = (char*) kmalloc(len + 1, GFP_KERNEL);
221 + if(!*bpath) {
222 + printk(KERN_CRIT "mini_fo: get_mini_fo_bpath: out of mem.\n");
223 + return -1;
224 + }
225 + buf_walker = *bpath+len; /* put it on last char */
226 + *buf_walker = '\n';
227 + sky_walker = dtohd(dentry);
228 +
229 + do {
230 + buf_walker -= sky_walker->d_name.len;
231 + strncpy(buf_walker,
232 + sky_walker->d_name.name,
233 + sky_walker->d_name.len);
234 + *(--buf_walker) = '/';
235 + sky_walker = sky_walker->d_parent;
236 + } while(sky_walker != stopd(dentry->d_inode->i_sb)->base_dir_dentry);
237 +
238 + /* bpath_len doesn't count newline! */
239 + *bpath_len = len;
240 + return 0;
241 +}
242 +
243 +int mini_fo_cp_cont(dentry_t *tgt_dentry, struct vfsmount *tgt_mnt,
244 + dentry_t *src_dentry, struct vfsmount *src_mnt)
245 +{
246 + void *buf;
247 + mm_segment_t old_fs;
248 + file_t *tgt_file;
249 + file_t *src_file;
250 + int bytes, len, tmp, err;
251 + err = 0;
252 +
253 + if(!(tgt_dentry->d_inode && src_dentry->d_inode)) {
254 + printk(KERN_CRIT "mini_fo_cp_cont: ERROR, neg. dentry passed.\n");
255 + err = -EINVAL;
256 + goto out;
257 + }
258 +
259 + dget(tgt_dentry);
260 + dget(src_dentry);
261 + mntget(tgt_mnt);
262 + mntget(src_mnt);
263 +
264 + /* open file write only */
265 + tgt_file = dentry_open(tgt_dentry, tgt_mnt, 0x1);
266 + if(!tgt_file || IS_ERR(tgt_file)) {
267 + printk(KERN_CRIT "mini_fo_cp_cont: ERROR opening target file.\n");
268 + err = PTR_ERR(tgt_file);
269 + goto out_err;
270 + }
271 +
272 + /* open file read only */
273 + src_file = dentry_open(src_dentry, src_mnt, 0x0);
274 + if(!src_file || IS_ERR(src_file)) {
275 + printk(KERN_CRIT "mini_fo_cp_cont: ERROR opening source file.\n");
276 + err = PTR_ERR(src_file);
277 +
278 + /* close target file */
279 + fput(tgt_file);
280 + goto out_err;
281 + }
282 +
283 + /* check if the filesystem(s) support read respective write */
284 + if(!src_file->f_op->read || !tgt_file->f_op->write) {
285 + printk(KERN_CRIT "mini_fo_cp_cont: ERROR, no fs read or write support.\n");
286 + err = -EPERM;
287 + goto out_close;
288 + }
289 +
290 + /* allocate a page for transfering the data */
291 + buf = (void *) __get_free_page(GFP_KERNEL);
292 + if(!buf) {
293 + printk(KERN_CRIT "mini_fo_cp_cont: ERROR, out of kernel mem.\n");
294 + goto out_err;
295 + }
296 +
297 + tgt_file->f_pos = 0;
298 + src_file->f_pos = 0;
299 +
300 + old_fs = get_fs();
301 + set_fs(KERNEL_DS);
302 +
303 + /* Doing this I assume that a read operation will return a full
304 + * buffer while there is still data to read, and a less than
305 + * full buffer when all data has been read.
306 + */
307 + bytes = len = PAGE_SIZE;
308 + while(bytes == len) {
309 + bytes = src_file->f_op->read(src_file, buf, len,
310 + &src_file->f_pos);
311 + tmp = tgt_file->f_op->write(tgt_file, buf, bytes,
312 + &tgt_file->f_pos);
313 + if(tmp != bytes) {
314 + printk(KERN_CRIT "mini_fo_cp_cont: ERROR writing.\n");
315 + goto out_close_unset;
316 + }
317 + }
318 +
319 + free_page((unsigned long) buf);
320 + set_fs(old_fs);
321 + fput(tgt_file);
322 + fput(src_file);
323 + goto out;
324 +
325 + out_close_unset:
326 + free_page((unsigned long) buf);
327 + set_fs(old_fs);
328 +
329 + out_close:
330 + fput(tgt_file);
331 + fput(src_file);
332 +
333 + out_err:
334 + dput(tgt_dentry);
335 + dput(src_dentry);
336 +
337 + /* mk: not sure if this need to be done */
338 + mntput(tgt_mnt);
339 + mntput(src_mnt);
340 +
341 + out:
342 + return err;
343 +}
344 +
345 +/* mk:
346 + * ndl (no-duplicate list) stuff
347 + * This is used in mini_fo_readdir, to save the storage directory contents
348 + * and later when reading base, match them against the list in order
349 + * to avoid duplicates.
350 + */
351 +
352 +/* add a file specified by name and len to the ndl
353 + * Return values: 0 on success, <0 on failure.
354 + */
355 +int ndl_add_entry(struct readdir_data *rd, const char *name, int len)
356 +{
357 + struct ndl_entry *tmp_entry;
358 +
359 + tmp_entry = (struct ndl_entry *)
360 + kmalloc(sizeof(struct ndl_entry), GFP_KERNEL);
361 + if(!tmp_entry) {
362 + printk(KERN_CRIT "mini_fo: ndl_add_entry: out of mem.\n");
363 + return -ENOMEM;
364 + }
365 + tmp_entry->name = (char*) kmalloc(len, GFP_KERNEL);
366 + if(!tmp_entry->name) {
367 + printk(KERN_CRIT "mini_fo: ndl_add_entry: out of mem.\n");
368 + return -ENOMEM;
369 + }
370 + strncpy(tmp_entry->name, name, len);
371 + tmp_entry->len = len;
372 +
373 + list_add(&tmp_entry->list, &rd->ndl_list);
374 + rd->ndl_size++;
375 + return 0;
376 +}
377 +
378 +/* delete all list entries and free memory */
379 +void ndl_put_list(struct readdir_data *rd)
380 +{
381 + struct list_head *tmp;
382 + struct ndl_entry *tmp_entry;
383 +
384 + if(rd->ndl_size <= 0)
385 + return;
386 + while(!list_empty(&rd->ndl_list)) {
387 + tmp = rd->ndl_list.next;
388 + list_del(tmp);
389 + tmp_entry = list_entry(tmp, struct ndl_entry, list);
390 + kfree(tmp_entry->name);
391 + kfree(tmp_entry);
392 + }
393 + rd->ndl_size = 0;
394 +}
395 +
396 +/* Check if a file specified by name and len is in the ndl
397 + * Return value: 0 if not in list, 1 if file is found in ndl.
398 + */
399 +int ndl_check_entry(struct readdir_data *rd, const char *name, int len)
400 +{
401 + struct list_head *tmp;
402 + struct ndl_entry *tmp_entry;
403 +
404 + if(rd->ndl_size <= 0)
405 + return 0;
406 +
407 + list_for_each(tmp, &rd->ndl_list) {
408 + tmp_entry = list_entry(tmp, struct ndl_entry, list);
409 + if(tmp_entry->len != len)
410 + continue;
411 + if(!strncmp(tmp_entry->name, name, len))
412 + return 1;
413 + }
414 + return 0;
415 +}
416 +
417 +/* mk:
418 + * Recursive function to create corresponding directorys in the storage fs.
419 + * The function will build the storage directorys up to dentry.
420 + */
421 +int build_sto_structure(dentry_t *dir, dentry_t *dentry)
422 +{
423 + int err;
424 + dentry_t *hidden_sto_dentry;
425 + dentry_t *hidden_sto_dir_dentry;
426 +
427 + if(dentry->d_parent != dir) {
428 + printk(KERN_CRIT "mini_fo: build_sto_structure: invalid parameter or meta data corruption [1].\n");
429 + return 1;
430 + }
431 +
432 + if(dtost(dir) != MODIFIED) {
433 + err = build_sto_structure(dir->d_parent, dentry->d_parent);
434 + if(err)
435 + return err;
436 + }
437 +
438 + /* ok, coming back again. */
439 + check_mini_fo_dentry(dentry);
440 + hidden_sto_dentry = dtohd2(dentry);
441 +
442 + if(!hidden_sto_dentry) {
443 + /*
444 + * This is the case after creating the first
445 + * hidden_sto_dentry.
446 + * After one negative storage_dentry, all pointers to
447 + * hidden_storage dentries are set to NULL. We need to
448 + * create the negative dentry before we create the storage
449 + * file.
450 + */
451 + unsigned int len;
452 + const unsigned char *name;
453 + len = dtohd(dentry)->d_name.len;
454 + name = dtohd(dentry)->d_name.name;
455 + hidden_sto_dentry = lookup_one_len(name, dtohd2(dir), len);
456 + dtohd2(dentry) = hidden_sto_dentry;
457 + }
458 +
459 + /* was: hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry); */
460 + hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
461 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
462 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
463 +#else
464 + down(&hidden_sto_dir_dentry->d_inode->i_sem);
465 +#endif
466 + /* lets be safe */
467 + if(dtohd2(dir) != hidden_sto_dir_dentry) {
468 + printk(KERN_CRIT "mini_fo: build_sto_structure: invalid parameter or meta data corruption [2].\n");
469 + return 1;
470 + }
471 +
472 + /* check for errors in lock_parent */
473 + err = PTR_ERR(hidden_sto_dir_dentry);
474 + if(IS_ERR(hidden_sto_dir_dentry)) {
475 + printk(KERN_CRIT "mini_fo: build_sto_structure: lock_parent failed.\n");
476 + return err;
477 + }
478 +
479 + err = vfs_mkdir(hidden_sto_dir_dentry->d_inode,
480 + hidden_sto_dentry,
481 + dir->d_inode->i_mode);
482 +
483 + if(err) {
484 + printk(KERN_CRIT "mini_fo: build_sto_structure: failed to create storage dir [1].\n");
485 + /* was: unlock_dir(dir); */
486 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
487 + mutex_unlock(&dir->d_inode->i_mutex);
488 +#else
489 + up(&dir->d_inode->i_sem);
490 +#endif
491 + dput(dir);
492 + return err;
493 + }
494 +
495 + /* everything ok! */
496 + if(!dtohd2(dentry)->d_inode) {
497 + printk(KERN_CRIT "mini_fo: build_sto_structure: failed to create storage dir [2].\n");
498 + /* was: unlock_dir(dir); */
499 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
500 + mutex_unlock(&dir->d_inode->i_mutex);
501 +#else
502 + up(&dir->d_inode->i_sem);
503 +#endif
504 + dput(dir);
505 + return 1;
506 + }
507 +
508 + /* interpose the new inode and set new state */
509 + itohi2(dentry->d_inode) = igrab(dtohd2(dentry)->d_inode);
510 + dtopd(dentry)->state = MODIFIED;
511 +
512 + /* initalize the wol list */
513 + itopd(dentry->d_inode)->deleted_list_size = -1;
514 + itopd(dentry->d_inode)->renamed_list_size = -1;
515 + meta_build_lists(dentry);
516 +
517 + fist_copy_attr_all(dentry->d_inode, itohi2(dentry->d_inode));
518 + fist_copy_attr_timesizes(dir->d_inode,
519 + hidden_sto_dir_dentry->d_inode);
520 + dir->d_inode->i_nlink++;
521 + /* was: unlock_dir(hidden_sto_dir_dentry); */
522 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
523 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
524 +#else
525 + up(&hidden_sto_dir_dentry->d_inode->i_sem);
526 +#endif
527 + dput(hidden_sto_dir_dentry);
528 + return 0;
529 +}
530 +
531 +
532 +#if 0 /* unused */
533 +
534 +/*
535 + * Read "len" bytes from "filename" into "buf".
536 + * "buf" is in kernel space.
537 + */
538 +int
539 +mini_fo_read_file(const char *filename, void *buf, int len)
540 +{
541 + file_t *filp;
542 + mm_segment_t oldfs;
543 + int bytes;
544 + /* Chroot? Maybe NULL isn't right here */
545 + filp = filp_open(filename, O_RDONLY, 0);
546 + if (!filp || IS_ERR(filp)) {
547 + printk("mini_fo_read_file err %d\n", (int) PTR_ERR(filp));
548 + return -1; /* or do something else */
549 + }
550 +
551 + if (!filp->f_op->read)
552 + return -2; /* file(system) doesn't allow reads */
553 +
554 + /* now read len bytes from offset 0 */
555 + filp->f_pos = 0; /* start offset */
556 + oldfs = get_fs();
557 + set_fs(KERNEL_DS);
558 + bytes = filp->f_op->read(filp, buf, len, &filp->f_pos);
559 + set_fs(oldfs);
560 +
561 + /* close the file */
562 + fput(filp);
563 +
564 + return bytes;
565 +}
566 +
567 +
568 +
569 +/*
570 + * Write "len" bytes from "buf" to "filename"
571 + * "buf" is in kernel space.
572 + */
573 +int
574 +mini_fo_write_file(const char *filename, void *buf, int len)
575 +{
576 + file_t *filp;
577 + mm_segment_t oldfs;
578 + int bytes;
579 + /* Chroot? Maybe NULL isn't right here */
580 + filp = filp_open(filename, O_RDWR|O_CREAT, 0640);
581 + if (!filp || IS_ERR(filp)) {
582 + printk("mini_fo_write_file err %d\n", (int) PTR_ERR(filp));
583 + return -1; /* or do something else */
584 + }
585 +
586 + if (!filp->f_op->write)
587 + return -2; /* file(system) doesn't allow writes */
588 +
589 + /* now write len bytes from offset 0 */
590 + filp->f_pos = 0; /* start offset */
591 + oldfs = get_fs();
592 + set_fs(KERNEL_DS);
593 + bytes = filp->f_op->write(filp, buf, len, &filp->f_pos);
594 + set_fs(oldfs);
595 +
596 + /* close the file */
597 + fput(filp);
598 +
599 + return bytes;
600 +}
601 +
602 +#endif /* unused */
603 +
604 --- /dev/null
605 +++ b/fs/mini_fo/ChangeLog
606 @@ -0,0 +1,281 @@
607 +2006-01-24 Markus Klotzbuecher <mk@mary.denx.de>
608 +
609 + * Add tons of ugly ifdefs to Ed L. Cashin's mutex patch to
610 + retain backwards compatibility.
611 +
612 +2006-01-24 Ed L. Cashin <ecashin@coraid.com>
613 +
614 + * Support for the new mutex infrastructure
615 + (7892f2f48d165a34b0b8130c8a195dfd807b8cb6)
616 +
617 +2005-10-15 Markus Klotzbuecher <mk@localhost.localdomain>
618 +
619 + * Bugfix for a serious memory leak in mini_fo_follow_link.
620 +
621 +2005-09-21 Markus Klotzbuecher <mk@mary>
622 +
623 + * new release 0.6.1
624 +
625 + * fix of a compiler warning due to changes in 2.6.13
626 +
627 +2005-09-21 Klaus Wenninger <klaus.wenninger@siemens.com>
628 +
629 + * file.c: readdir: fix for a bug that caused directory entries
630 + to show up twice when using storage filesystems such as
631 + minixfs or pramfs.
632 +
633 +2005-06-30 Eric Lammerts <eric@lammerts.org>
634 +
635 + * fix for an oops when overwriting a binary thats beeing
636 + executed.
637 +
638 +2005-06-09 <mk@mary>
639 +
640 + * Renamed overlay to mini_fo-overlay.
641 +
642 + * Added mini_fo-merge script to allow merging of storage and base
643 + after making modifications.
644 +
645 +2005-05-22 root <mk@mary>
646 +
647 + * Added overlay script that allows to easily mount mini_fo ontop
648 + of a given base directory
649 +
650 +2005-05-10 <mk@mary>
651 +
652 + * inode.c: xattr functions return -EOPNOSUPP instead of
653 + -ENOSUPP, what confuses "ls -l"
654 +
655 + * Changed license from LGPL to GPL.
656 +
657 +2005-05-08 root <mk@mary>
658 +
659 + * Makefile: clean it up and added make install and make
660 + uninstall.
661 +
662 +2005-05-06 <mk@mary>
663 +
664 + * merged devel branch back to main. [v0-6-0-pre3]
665 +
666 + * removed unused files print.c and fist_ioctl. [devel-0-0-18]
667 +
668 + * ioctl: removed fist_ioctl stuff, that is not needed for
669 + now.
670 +
671 +2005-05-03 <mk@mary>
672 +
673 + * file.c: simplified mini_fo_open and mini_fo_setattr using
674 + new state changing functions. [devel-0-0-17]
675 +
676 + * inode.c: Fixed getattr state bug (see below) in 2.4 function
677 + mini_fo_inode revalidate.
678 +
679 + * inode.c: found an other bug in mini_fo_getattr. States are not
680 + reliable in this function, as a file can be opened, unlinked and
681 + the getattr function called. This results in a deleted dentry
682 + with an inode. Fix is to ignore states and simply use the inode
683 + available.
684 +
685 +2005-04-29 <mk@mary>
686 +
687 + * file.c: Bugfix and cleanup in fasync and fsync. [devel-0-0-16]
688 +
689 + * file.c: do not use mini_fo_lock so the generic version is
690 + used (I guess).
691 +
692 + * inode.c: getattr, never call getattr on lower files, as this
693 + will cause the inum to change.
694 +
695 + * inode.c: rename_reg_file renamed to rename_nondir, as it
696 + doesn't matter as long it't not a dir. Removed all
697 + rename_dev_file etc.
698 +
699 + * tagged as devel-0-0-15
700 +
701 + * inode.c: added support for chosing support for extended
702 + attrs at compile time by XATTR define in mini_fo.h .
703 +
704 + * inode.c: fixed mini_fo_getattr to use mini_fo inode and not
705 + lower again, what avoids inode number changes that confused
706 + rm again. This is the proper solution.
707 +
708 +2005-04-24 <mk@mary>
709 +
710 + * all files: updated Copyright notive to 2005. [devel-0-0-14]
711 +
712 + * inode.c: fixed mini_fo_getattr to not change the inode
713 + number, even if lower files change.
714 +
715 + * super.c: fixed a bug that caused deleted base file to show
716 + up suddenly after some time, or after creating a special
717 + file. The problem was that after some time or after special
718 + file creating sync_sb_inodes is called by the vfs, that
719 + called our mini_fo_put_inode. There was (wrongly) called
720 + __meta_put_lists, that nuked the lists, although the inode
721 + was going to continue its life. Moving __meta_put_lists to
722 + mini_fo_clear_inode, where an inode is really destroyed,
723 + solved the problem.
724 +
725 +
726 +2005-04-23 <mk@mary>
727 +
728 + * state.c, aux.c: more cleaning up and
729 + simplifications. [devel-0-0-13]
730 +
731 + * inode.c: implemented mini_fo_getattr, that was required for
732 + 2.6 because inode_revalidate has been remove there, and the
733 + old "du" bug returned.
734 +
735 +
736 +2005-04-20 <mk@mary>
737 +
738 + * aux.c: get_neg_sto_dentry(): allow to be called for dentries
739 + in state UNMODIFIED, NON_EXISTANT _and_ DELETED.
740 +
741 +2005-04-19 <mk@mary>
742 +
743 + * Fixed a bug under 2.6 that caused files deleted via mini_fo
744 + not to be deleted properly and therefore the fs filled up
745 + untill no memory was left. [devel-0-0-12]
746 +
747 + * Added basic hard link support. This means that creating
748 + hardlinks will work, but existing ones will be treated as
749 + individual files. [devel-0-0-11]
750 +
751 +2005-04-17 <mk@mary>
752 +
753 + * Bugfixes
754 +
755 +2005-04-13 root <mk@mary>
756 +
757 + * Added file state.c for the state transition
758 + functions. Doesn't work very well yet, though...
759 +
760 +2005-04-12 <mk@mary>
761 +
762 + * Porting to 2.6 started, which is easier than expected, also
763 + due to Olivier previous work.
764 +
765 +2005-04-08 <mk@mary>
766 +
767 + * Fixed the bug that caused du to return invalid sizes of
768 + directory trees. The problem was that
769 + mini_fo_inode_revalidate didn't always copy the attributes
770 + from the base inode properly.
771 +
772 +2005-04-01 Markus Klotzbuecher <mk@chasey>
773 +
774 + * Merged devel branch back to main trunk and updated the
775 + RELEASE notes. This will be 0-6-0-pre1.
776 +
777 +2005-03-31 Markus Klotzbuecher <mk@chasey>
778 +
779 + * Fixed some bugs in rename_reg_file, that only showed up in
780 + the kernel compile test. Kernel compiles cleanly ontop of
781 + mini_fo, now also make mrproper etc. work. Seems pretty stable.
782 +
783 +2005-03-28 Markus Klotzbuecher <mk@chasey>
784 +
785 + * Many, many directory renaming bugfixes and a lot of other
786 + cleanup. Dir renaming seems to work relatively stable.
787 +
788 +2005-03-22 Markus Klotzbuecher <mk@chasey>
789 +
790 + * Finished implementing lightweight directory renaming. Some
791 + basic testing indicates it works fine.
792 + Next is to implement testcases for the testsuite and confirm
793 + everything is really working ok.
794 +
795 +2005-03-18 Markus Klotzbuecher <mk@chasey>
796 +
797 + * Finished implementing meta.c stuff required for directory
798 + renaming.
799 +
800 +2005-03-17 Markus Klotzbuecher <mk@chasey>
801 +
802 + * Fixed all compile warnings + an extremly old bug that
803 + somehow crept in while reworking the wol stuff to the META
804 + system. Turning on -Werror again... :-)
805 +
806 + * Fixed some bugs in the new rename_reg_file function.
807 +
808 + * Rewrote mini_fo rename and split it into several
809 + subfunctions, that handle the different types
810 + seperately. Rewrote the regular file function aswell, as it
811 + was implemented somewhat inefficient.
812 +
813 +2005-03-16 Markus Klotzbuecher <mk@chasey>
814 +
815 + * Implemented new META subsystem, removed old WOL stuff in favor
816 + if it.
817 +
818 + * After some basic testing everything seems ok...
819 +
820 +2005-03-11 Markus Klotzbuecher <mk@chasey>
821 +
822 + * Renaming a non regular file caused trouble because I always
823 + tried to copy the contents. Now I only do this for regular
824 + files. mini_fo_rename still isn't implemented properly, renaming
825 + of device files, symlinks etc. results in a empty regular file
826 + instead of the proper type.
827 +
828 + * Directory renaming suddenly works! What a surprise! I guess
829 + this is because renaming is implemented as making a copy and
830 + removing the original. Still this might not work
831 + everywhere...
832 +
833 +2005-03-09 Markus Klotzbuecher <mk@chasey>
834 +
835 + * Bugfix, when a mini_fo directory that exists in storage
836 + (state: MODIFIED, CREATED and DEL_REWRITTEN) is deleted, a
837 + possibly existing WOL file contained in it needs to be
838 + deleted too.
839 +
840 + * Starting cleanup: defined state names in order to get rid of
841 + the state numbers.
842 +
843 +2005-03-08 Markus Klotzbuecher <mk@chasey>
844 +
845 + * Makefile fix, fist_ioctl was built against wrong sources if ARCH=um
846 +
847 + * Fixed a bug in dentry.c, mini_fo_d_hash. In state 4 =
848 + DEL_REWRITTEN the hash was calculated from the base dentry,
849 + which was wrong and and caused assertions in
850 + __mini_fo_hidden_dentry to fail.
851 +
852 +2005-02-21 <mk@mary>
853 +
854 + * Implemented directory deleting (inode.c)
855 +
856 + * main.c: made mini_fo_parse_options a little more robust.
857 +
858 +2004-12-22 <mk@mary>
859 +
860 + * Makefile cleanup and uml stuff, removed unneccessary files
861 +
862 + * Created a new and hopefully more informative README
863 +
864 + * CHANGELOG: created a new CHANGELOG and added old entries reversely
865 +
866 +
867 +2004-10-24 Gleb Natapov <gleb@nbase.co.il>
868 +
869 + * Fix: owner and group where not correctly copied from base to
870 + storage.
871 +
872 +
873 +2004-10-05 Gleb Natapov <gleb@nbase.co.il>
874 +
875 + * Implementation of fsync, fasync and lock mini_fo functions.
876 +
877 +
878 +2004-09-29 Bob Lee <bob@pantasys.com>
879 +
880 + * Fix of a serious pointer bug
881 +
882 +
883 +2004-09-28 Gleb Natapov <gleb@nbase.co.il>
884 +
885 + * Implementation of mini_fo_mknod and mini_fo_rename, support
886 + for device files.
887 +
888 --- /dev/null
889 +++ b/fs/mini_fo/dentry.c
890 @@ -0,0 +1,244 @@
891 +/*
892 + * Copyright (c) 1997-2003 Erez Zadok
893 + * Copyright (c) 2001-2003 Stony Brook University
894 + *
895 + * For specific licensing information, see the COPYING file distributed with
896 + * this package, or get one from ftp://ftp.filesystems.org/pub/fist/COPYING.
897 + *
898 + * This Copyright notice must be kept intact and distributed with all
899 + * fistgen sources INCLUDING sources generated by fistgen.
900 + */
901 +/*
902 + * Copyright (C) 2004, 2005 Markus Klotzbuecher <mk@creamnet.de>
903 + *
904 + * This program is free software; you can redistribute it and/or
905 + * modify it under the terms of the GNU General Public License
906 + * as published by the Free Software Foundation; either version
907 + * 2 of the License, or (at your option) any later version.
908 + */
909 +
910 +/*
911 + * $Id$
912 + */
913 +
914 +#ifdef HAVE_CONFIG_H
915 +# include <config.h>
916 +#endif
917 +
918 +#include "fist.h"
919 +#include "mini_fo.h"
920 +
921 +/*
922 + * THIS IS A BOOLEAN FUNCTION: returns 1 if valid, 0 otherwise.
923 + */
924 +STATIC int
925 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
926 +mini_fo_d_revalidate(dentry_t *dentry, struct nameidata *nd)
927 +#else
928 +mini_fo_d_revalidate(dentry_t *dentry, int flags)
929 +#endif
930 +{
931 + int err1 = 1; /* valid = 1, invalid = 0 */
932 + int err2 = 1;
933 + dentry_t *hidden_dentry;
934 + dentry_t *hidden_sto_dentry;
935 +
936 +
937 + check_mini_fo_dentry(dentry);
938 +
939 + hidden_dentry = dtohd(dentry);
940 + hidden_sto_dentry = dtohd2(dentry);
941 +
942 + if(hidden_dentry &&
943 + hidden_dentry->d_op &&
944 + hidden_dentry->d_op->d_revalidate) {
945 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
946 + err1 = hidden_dentry->d_op->d_revalidate(hidden_dentry, nd);
947 +#else
948 + err1 = hidden_dentry->d_op->d_revalidate(hidden_dentry, flags);
949 +#endif
950 + }
951 + if(hidden_sto_dentry &&
952 + hidden_sto_dentry->d_op &&
953 + hidden_sto_dentry->d_op->d_revalidate) {
954 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
955 + err2 = hidden_sto_dentry->d_op->d_revalidate(hidden_sto_dentry,
956 + nd);
957 +#else
958 + err2 = hidden_sto_dentry->d_op->d_revalidate(hidden_sto_dentry,
959 + flags);
960 +#endif
961 + }
962 +
963 + /* mk: if one of the lower level dentries are valid,
964 + * the mini_fo dentry is too.
965 + */
966 + return (err1 || err2);
967 +}
968 +
969 +
970 +STATIC int
971 +mini_fo_d_hash(dentry_t *dentry, qstr_t *name)
972 +{
973 + int err = 0;
974 + dentry_t *hidden_dentry;
975 + dentry_t *hidden_sto_dentry;
976 +
977 + /* hidden_dentry = mini_fo_hidden_dentry(dentry);
978 + * hidden_sto_dentry = mini_fo_hidden_sto_dentry(dentry); */
979 +
980 + /* state 1, 3, 4, 5: build the hash for the storage dentry */
981 + if((dtopd(dentry)->state == MODIFIED) ||
982 + (dtopd(dentry)->state == CREATED) ||
983 + (dtopd(dentry)->state == DEL_REWRITTEN) ||
984 + (dtopd(dentry)->state == DELETED)) {
985 + hidden_sto_dentry = dtohd2(dentry);
986 + if(hidden_sto_dentry &&
987 + hidden_sto_dentry->d_op &&
988 + hidden_sto_dentry->d_op->d_hash) {
989 + err = hidden_sto_dentry->d_op->d_hash(hidden_sto_dentry, name);
990 + }
991 + goto out;
992 + }
993 + /* state 2: build the hash for the base dentry */
994 + if(dtopd(dentry)->state == UNMODIFIED) {
995 + hidden_dentry = dtohd(dentry);
996 + if(hidden_dentry &&
997 + hidden_dentry->d_op &&
998 + hidden_dentry->d_op->d_hash) {
999 + err = hidden_dentry->d_op->d_hash(hidden_dentry, name);
1000 + }
1001 + goto out;
1002 + }
1003 + /* state 6: build hash for the dentry that exists */
1004 + if(dtopd(dentry)->state == NON_EXISTANT) {
1005 + hidden_sto_dentry = dtohd2(dentry);
1006 + if(hidden_sto_dentry &&
1007 + hidden_sto_dentry->d_op &&
1008 + hidden_sto_dentry->d_op->d_hash) {
1009 + err = hidden_sto_dentry->d_op->d_hash(hidden_sto_dentry, name);
1010 + goto out;
1011 + }
1012 + hidden_dentry = dtohd(dentry);
1013 + if(hidden_dentry &&
1014 + hidden_dentry->d_op &&
1015 + hidden_dentry->d_op->d_hash) {
1016 + err = hidden_dentry->d_op->d_hash(hidden_dentry, name);
1017 + goto out;
1018 + }
1019 + }
1020 +
1021 + printk(KERN_CRIT "mini_fo: d_hash: invalid state detected.\n");
1022 +
1023 + out:
1024 + return err;
1025 +}
1026 +
1027 +
1028 +STATIC int
1029 +mini_fo_d_compare(dentry_t *dentry, qstr_t *a, qstr_t *b)
1030 +{
1031 + int err;
1032 + dentry_t *hidden_dentry=NULL;
1033 +
1034 + /* hidden_dentry = mini_fo_hidden_dentry(dentry); */
1035 + if(dtohd2(dentry))
1036 + hidden_dentry = dtohd2(dentry);
1037 + else if(dtohd(dentry))
1038 + hidden_dentry = dtohd(dentry);
1039 +
1040 + if (hidden_dentry && hidden_dentry->d_op && hidden_dentry->d_op->d_compare) {
1041 + err = hidden_dentry->d_op->d_compare(hidden_dentry, a, b);
1042 + } else {
1043 + err = ((a->len != b->len) || memcmp(a->name, b->name, b->len));
1044 + }
1045 +
1046 + return err;
1047 +}
1048 +
1049 +
1050 +int
1051 +mini_fo_d_delete(dentry_t *dentry)
1052 +{
1053 + dentry_t *hidden_dentry;
1054 + dentry_t *hidden_sto_dentry;
1055 + int err = 0;
1056 +
1057 + /* this could be a negative dentry, so check first */
1058 + if (!dtopd(dentry)) {
1059 + printk(KERN_CRIT "mini_fo_d_delete: negative dentry passed.\n");
1060 + goto out;
1061 + }
1062 + hidden_dentry = dtohd(dentry);
1063 + hidden_sto_dentry = dtohd2(dentry);
1064 +
1065 + if(hidden_dentry) {
1066 + if(hidden_dentry->d_op &&
1067 + hidden_dentry->d_op->d_delete) {
1068 + err = hidden_dentry->d_op->d_delete(hidden_dentry);
1069 + }
1070 + }
1071 + if(hidden_sto_dentry) {
1072 + if(hidden_sto_dentry->d_op &&
1073 + hidden_sto_dentry->d_op->d_delete) {
1074 + err = hidden_sto_dentry->d_op->d_delete(hidden_sto_dentry);
1075 + }
1076 + }
1077 +
1078 + out:
1079 + return err;
1080 +}
1081 +
1082 +
1083 +void
1084 +mini_fo_d_release(dentry_t *dentry)
1085 +{
1086 + dentry_t *hidden_dentry;
1087 + dentry_t *hidden_sto_dentry;
1088 +
1089 +
1090 + /* this could be a negative dentry, so check first */
1091 + if (!dtopd(dentry)) {
1092 + printk(KERN_CRIT "mini_fo_d_release: no private data.\n");
1093 + goto out;
1094 + }
1095 + hidden_dentry = dtohd(dentry);
1096 + hidden_sto_dentry = dtohd2(dentry);
1097 +
1098 + if(hidden_dentry) {
1099 + /* decrement hidden dentry's counter and free its inode */
1100 + dput(hidden_dentry);
1101 + }
1102 + if(hidden_sto_dentry) {
1103 + /* decrement hidden dentry's counter and free its inode */
1104 + dput(hidden_sto_dentry);
1105 + }
1106 +
1107 + /* free private data (mini_fo_dentry_info) here */
1108 + kfree(dtopd(dentry));
1109 + __dtopd(dentry) = NULL; /* just to be safe */
1110 + out:
1111 + return;
1112 +}
1113 +
1114 +
1115 +/*
1116 + * we don't really need mini_fo_d_iput, because dentry_iput will call iput() if
1117 + * mini_fo_d_iput is not defined. We left this implemented for ease of
1118 + * tracing/debugging.
1119 + */
1120 +void
1121 +mini_fo_d_iput(dentry_t *dentry, inode_t *inode)
1122 +{
1123 + iput(inode);
1124 +}
1125 +
1126 +
1127 +struct dentry_operations mini_fo_dops = {
1128 + d_revalidate: mini_fo_d_revalidate,
1129 + d_hash: mini_fo_d_hash,
1130 + d_compare: mini_fo_d_compare,
1131 + d_release: mini_fo_d_release,
1132 + d_delete: mini_fo_d_delete,
1133 + d_iput: mini_fo_d_iput,
1134 +};
1135 --- /dev/null
1136 +++ b/fs/mini_fo/file.c
1137 @@ -0,0 +1,717 @@
1138 +/*
1139 + * Copyright (c) 1997-2003 Erez Zadok
1140 + * Copyright (c) 2001-2003 Stony Brook University
1141 + *
1142 + * For specific licensing information, see the COPYING file distributed with
1143 + * this package, or get one from ftp://ftp.filesystems.org/pub/fist/COPYING.
1144 + *
1145 + * This Copyright notice must be kept intact and distributed with all
1146 + * fistgen sources INCLUDING sources generated by fistgen.
1147 + */
1148 +/*
1149 + * Copyright (C) 2004, 2005 Markus Klotzbuecher <mk@creamnet.de>
1150 + *
1151 + * This program is free software; you can redistribute it and/or
1152 + * modify it under the terms of the GNU General Public License
1153 + * as published by the Free Software Foundation; either version
1154 + * 2 of the License, or (at your option) any later version.
1155 + */
1156 +
1157 +/*
1158 + * $Id$
1159 + */
1160 +
1161 +#ifdef HAVE_CONFIG_H
1162 +# include <config.h>
1163 +#endif
1164 +
1165 +#include "fist.h"
1166 +#include "mini_fo.h"
1167 +#define ROUND_UP(x) (((x)+sizeof(long)-1) & ~(sizeof(long)-1))
1168 +
1169 +/*******************
1170 + * File Operations *
1171 + *******************/
1172 +
1173 +STATIC loff_t
1174 +mini_fo_llseek(file_t *file, loff_t offset, int origin)
1175 +{
1176 + loff_t err;
1177 + file_t *hidden_file = NULL;
1178 +
1179 + if(S_ISDIR(file->f_dentry->d_inode->i_mode)) {
1180 + /* Check if trying to llseek from a directory */
1181 + err = -EISDIR;
1182 + goto out;
1183 + }
1184 + if (ftopd(file) != NULL) {
1185 + if(ftohf2(file)) {
1186 + hidden_file = ftohf2(file);
1187 + } else {
1188 + hidden_file = ftohf(file);
1189 + }
1190 + }
1191 +
1192 + /* always set hidden position to this one */
1193 + hidden_file->f_pos = file->f_pos;
1194 +
1195 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
1196 + memcpy(&(hidden_file->f_ra),
1197 + &(file->f_ra),
1198 + sizeof(struct file_ra_state));
1199 +#else
1200 + if (file->f_reada) { /* update readahead information if needed */
1201 + hidden_file->f_reada = file->f_reada;
1202 + hidden_file->f_ramax = file->f_ramax;
1203 + hidden_file->f_raend = file->f_raend;
1204 + hidden_file->f_ralen = file->f_ralen;
1205 + hidden_file->f_rawin = file->f_rawin;
1206 + }
1207 +#endif
1208 + if (hidden_file->f_op && hidden_file->f_op->llseek)
1209 + err = hidden_file->f_op->llseek(hidden_file, offset, origin);
1210 + else
1211 + err = generic_file_llseek(hidden_file, offset, origin);
1212 +
1213 + if (err < 0)
1214 + goto out;
1215 +
1216 + if (err != file->f_pos) {
1217 + file->f_pos = err;
1218 + // ION maybe this?
1219 + // file->f_pos = hidden_file->f_pos;
1220 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
1221 + file->f_reada = 0;
1222 +#endif
1223 + file->f_version++;
1224 + }
1225 +
1226 + out:
1227 + return err;
1228 +}
1229 +
1230 +
1231 +/* mk: fanout capable */
1232 +STATIC ssize_t
1233 +mini_fo_read(file_t *file, char *buf, size_t count, loff_t *ppos)
1234 +{
1235 + int err = -EINVAL;
1236 + file_t *hidden_file = NULL;
1237 + loff_t pos = *ppos;
1238 +
1239 + if(S_ISDIR(file->f_dentry->d_inode->i_mode)) {
1240 + /* Check if trying to read from a directory */
1241 + /* printk(KERN_CRIT "mini_fo_read: ERROR: trying to read data from a directory.\n"); */
1242 + err = -EISDIR;
1243 + goto out;
1244 + }
1245 +
1246 + if (ftopd(file) != NULL) {
1247 + if(ftohf2(file)) {
1248 + hidden_file = ftohf2(file);
1249 + } else {
1250 + hidden_file = ftohf(file);
1251 + }
1252 + }
1253 +
1254 + if (!hidden_file->f_op || !hidden_file->f_op->read)
1255 + goto out;
1256 +
1257 + err = hidden_file->f_op->read(hidden_file, buf, count, &pos);
1258 + *ppos = pos;
1259 +
1260 + if (err >= 0) {
1261 + /* atime should also be updated for reads of size zero or more */
1262 + fist_copy_attr_atime(file->f_dentry->d_inode,
1263 + hidden_file->f_dentry->d_inode);
1264 + }
1265 +
1266 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
1267 + /*
1268 + * MAJOR HACK
1269 + * because pread() does not have any way to tell us that it is
1270 + * our caller, then we don't know for sure if we have to update
1271 + * the file positions. This hack relies on read() having passed us
1272 + * the "real" pointer of its struct file's f_pos field.
1273 + */
1274 + if (ppos == &file->f_pos)
1275 + hidden_file->f_pos = *ppos = pos;
1276 + if (hidden_file->f_reada) { /* update readahead information if needed */
1277 + file->f_reada = hidden_file->f_reada;
1278 + file->f_ramax = hidden_file->f_ramax;
1279 + file->f_raend = hidden_file->f_raend;
1280 + file->f_ralen = hidden_file->f_ralen;
1281 + file->f_rawin = hidden_file->f_rawin;
1282 + }
1283 +#else
1284 + memcpy(&(file->f_ra),&(hidden_file->f_ra),sizeof(struct file_ra_state));
1285 +#endif
1286 +
1287 + out:
1288 + return err;
1289 +}
1290 +
1291 +
1292 +/* this mini_fo_write() does not modify data pages! */
1293 +STATIC ssize_t
1294 +mini_fo_write(file_t *file, const char *buf, size_t count, loff_t *ppos)
1295 +{
1296 + int err = -EINVAL;
1297 + file_t *hidden_file = NULL;
1298 + inode_t *inode;
1299 + inode_t *hidden_inode;
1300 + loff_t pos = *ppos;
1301 +
1302 + /* mk: fan out: */
1303 + if (ftopd(file) != NULL) {
1304 + if(ftohf2(file)) {
1305 + hidden_file = ftohf2(file);
1306 + } else {
1307 + /* This is bad! We have no storage file to write to. This
1308 + * should never happen because if a file is opened for
1309 + * writing, a copy should have been made earlier.
1310 + */
1311 + printk(KERN_CRIT "mini_fo: write : ERROR, no storage file to write.\n");
1312 + err = -EINVAL;
1313 + goto out;
1314 + }
1315 + }
1316 +
1317 + inode = file->f_dentry->d_inode;
1318 + hidden_inode = itohi2(inode);
1319 + if(!hidden_inode) {
1320 + printk(KERN_CRIT "mini_fo: write: no sto inode found, not good.\n");
1321 + goto out;
1322 + }
1323 +
1324 + if (!hidden_file->f_op || !hidden_file->f_op->write)
1325 + goto out;
1326 +
1327 + /* adjust for append -- seek to the end of the file */
1328 + if (file->f_flags & O_APPEND)
1329 + pos = inode->i_size;
1330 +
1331 + err = hidden_file->f_op->write(hidden_file, buf, count, &pos);
1332 +
1333 + /*
1334 + * copy ctime and mtime from lower layer attributes
1335 + * atime is unchanged for both layers
1336 + */
1337 + if (err >= 0)
1338 + fist_copy_attr_times(inode, hidden_inode);
1339 +
1340 + *ppos = pos;
1341 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
1342 + /*
1343 + * XXX: MAJOR HACK
1344 + *
1345 + * because pwrite() does not have any way to tell us that it is
1346 + * our caller, then we don't know for sure if we have to update
1347 + * the file positions. This hack relies on write() having passed us
1348 + * the "real" pointer of its struct file's f_pos field.
1349 + */
1350 + if (ppos == &file->f_pos)
1351 + hidden_file->f_pos = *ppos = pos;
1352 +#endif
1353 + /* update this inode's size */
1354 + if (pos > inode->i_size)
1355 + inode->i_size = pos;
1356 +
1357 + out:
1358 + return err;
1359 +}
1360 +
1361 +/* Global variable to hold a file_t pointer.
1362 + * This serves to allow mini_fo_filldir function to know which file is
1363 + * beeing read, which is required for two reasons:
1364 + *
1365 + * - be able to call wol functions in order to avoid listing deleted
1366 + * base files.
1367 + * - if we're reading a directory which is in state 1, we need to
1368 + * maintain a list (in mini_fo_filldir) of which files allready
1369 + * have been copied to userspace,to detect files existing in base
1370 + * and storage and not list them twice.
1371 + */
1372 +filldir_t mini_fo_filldir_orig;
1373 +file_t *mini_fo_filldir_file;
1374 +
1375 +/* mainly copied from fs/readdir.c */
1376 +STATIC int
1377 +mini_fo_filldir(void * __buf, const char * name, int namlen, loff_t offset,
1378 + ino_t ino, unsigned int d_type)
1379 +{
1380 + struct linux_dirent *dirent, d;
1381 + struct getdents_callback * buf = (struct getdents_callback *) __buf;
1382 + int reclen;
1383 + file_t* file = mini_fo_filldir_file;
1384 +
1385 + /* In theses states we filter meta files in storage (WOL) */
1386 + if(file && (dtopd(file->f_dentry)->state == MODIFIED ||
1387 + dtopd(file->f_dentry)->state == CREATED ||
1388 + dtopd(file->f_dentry)->state == DEL_REWRITTEN)) {
1389 +
1390 + int tmp = strlen(META_FILENAME);
1391 + if(tmp == namlen) {
1392 + if(!strncmp(name, META_FILENAME, namlen))
1393 + return 0;
1394 + }
1395 + }
1396 +
1397 + /* check if we are merging the contents of storage and base */
1398 + if(file && dtopd(file->f_dentry)->state == MODIFIED) {
1399 + /* check if we are still reading storage contents, if
1400 + * yes, we just save the name of the file for duplicate
1401 + * checking later. */
1402 +
1403 + if(!ftopd(file)->rd.sto_done) {
1404 + /* put file into ndl list */
1405 + if(ndl_add_entry(&ftopd(file)->rd, name, namlen))
1406 + printk(KERN_CRIT "mini_fo_filldir: Error adding to ndl.\n");
1407 + } else {
1408 + /* check if file has been deleted */
1409 + if(meta_check_d_entry(file->f_dentry, name, namlen))
1410 + return 0;
1411 +
1412 + /* do duplicate checking */
1413 + if(ndl_check_entry(&ftopd(file)->rd, name, namlen))
1414 + return 0;
1415 + }
1416 + }
1417 +
1418 + return mini_fo_filldir_orig(buf, name, namlen, offset, ino, d_type);
1419 +}
1420 +
1421 +
1422 +STATIC int
1423 +mini_fo_readdir(file_t *file, void *dirent, filldir_t filldir)
1424 +{
1425 + int err = 0;/* mk: ??? -ENOTDIR; */
1426 + file_t *hidden_file = NULL;
1427 + file_t *hidden_sto_file = NULL;
1428 + inode_t *inode;
1429 + struct getdents_callback *buf;
1430 + int oldcount;
1431 +
1432 +#if defined(FIST_FILTER_NAME) || defined(FIST_FILTER_SCA)
1433 + struct mini_fo_getdents_callback buf;
1434 +#endif /* FIST_FILTER_NAME || FIST_FILTER_SCA */
1435 +
1436 + buf = (struct getdents_callback *) dirent;
1437 + oldcount = buf->count;
1438 + inode = file->f_dentry->d_inode;
1439 + mini_fo_filldir_file = file;
1440 + mini_fo_filldir_orig = filldir;
1441 +
1442 + ftopd(file)->rd.sto_done = 0;
1443 + do {
1444 + if (ftopd(file) != NULL) {
1445 + if(ftohf2(file)) {
1446 + hidden_sto_file = ftohf2(file);
1447 + err = vfs_readdir(hidden_sto_file, mini_fo_filldir, dirent);
1448 + file->f_pos = hidden_sto_file->f_pos;
1449 + if (err > 0)
1450 + fist_copy_attr_atime(inode, hidden_sto_file->f_dentry->d_inode);
1451 + /* not finshed yet, we'll be called again */
1452 + if (buf->count != oldcount)
1453 + break;
1454 + }
1455 +
1456 + ftopd(file)->rd.sto_done = 1;
1457 +
1458 + if(ftohf(file)) {
1459 + hidden_file = ftohf(file);
1460 + err = vfs_readdir(hidden_file, mini_fo_filldir, dirent);
1461 + file->f_pos = hidden_file->f_pos;
1462 + if (err > 0)
1463 + fist_copy_attr_atime(inode, hidden_file->f_dentry->d_inode);
1464 + }
1465 +
1466 + }
1467 + } while (0);
1468 +
1469 + /* mk:
1470 + * we need to check if all the directory data has been copied to userspace,
1471 + * or if we will be called again by userspace to complete the operation.
1472 + */
1473 + if(buf->count == oldcount) {
1474 + ndl_put_list(&ftopd(file)->rd);
1475 + }
1476 +
1477 + /* unset this, safe */
1478 + mini_fo_filldir_file = NULL;
1479 + return err;
1480 +}
1481 +
1482 +
1483 +STATIC unsigned int
1484 +mini_fo_poll(file_t *file, poll_table *wait)
1485 +{
1486 + unsigned int mask = DEFAULT_POLLMASK;
1487 + file_t *hidden_file = NULL;
1488 +
1489 + if (ftopd(file) != NULL) {
1490 + if(ftohf2(file)) {
1491 + hidden_file = ftohf2(file);
1492 + } else {
1493 + hidden_file = ftohf(file);
1494 + }
1495 + }
1496 +
1497 + if (!hidden_file->f_op || !hidden_file->f_op->poll)
1498 + goto out;
1499 +
1500 + mask = hidden_file->f_op->poll(hidden_file, wait);
1501 +
1502 + out:
1503 + return mask;
1504 +}
1505 +
1506 +/* FIST-LITE special version of mmap */
1507 +STATIC int
1508 +mini_fo_mmap(file_t *file, vm_area_t *vma)
1509 +{
1510 + int err = 0;
1511 + file_t *hidden_file = NULL;
1512 +
1513 + /* fanout capability */
1514 + if (ftopd(file) != NULL) {
1515 + if(ftohf2(file)) {
1516 + hidden_file = ftohf2(file);
1517 + } else {
1518 + hidden_file = ftohf(file);
1519 + }
1520 + }
1521 +
1522 + ASSERT(hidden_file != NULL);
1523 + ASSERT(hidden_file->f_op != NULL);
1524 + ASSERT(hidden_file->f_op->mmap != NULL);
1525 +
1526 + vma->vm_file = hidden_file;
1527 + err = hidden_file->f_op->mmap(hidden_file, vma);
1528 + get_file(hidden_file); /* make sure it doesn't get freed on us */
1529 + fput(file); /* no need to keep extra ref on ours */
1530 +
1531 + return err;
1532 +}
1533 +
1534 +
1535 +
1536 +STATIC int
1537 +mini_fo_open(inode_t *inode, file_t *file)
1538 +{
1539 + int err = 0;
1540 + int hidden_flags;
1541 + file_t *hidden_file = NULL;
1542 + dentry_t *hidden_dentry = NULL;
1543 +
1544 + /* fanout stuff */
1545 + file_t *hidden_sto_file = NULL;
1546 + dentry_t *hidden_sto_dentry = NULL;
1547 +
1548 + __ftopd(file) =
1549 + kmalloc(sizeof(struct mini_fo_file_info), GFP_KERNEL);
1550 + if (!ftopd(file)) {
1551 + err = -ENOMEM;
1552 + goto out;
1553 + }
1554 +
1555 + /* init the readdir_helper structure */
1556 + INIT_LIST_HEAD(&ftopd(file)->rd.ndl_list);
1557 + ftopd(file)->rd.ndl_size = 0;
1558 +
1559 + /* In certain paths this could stay uninitalized and cause trouble */
1560 + ftohf(file) = NULL;
1561 + ftohf2(file) = NULL;
1562 + hidden_flags = file->f_flags;
1563 +
1564 + /* create storage files? */
1565 + if(dtost(file->f_dentry) == UNMODIFIED) {
1566 + if(!IS_WRITE_FLAG(file->f_flags)) {
1567 + hidden_dentry = dtohd(file->f_dentry);
1568 + dget(hidden_dentry);
1569 + /* dentry_open will decrement mnt refcnt if err.
1570 + * otherwise fput() will do an mntput() for us upon file close. */
1571 + mntget(stopd(inode->i_sb)->hidden_mnt);
1572 + hidden_file = dentry_open(hidden_dentry,
1573 + stopd(inode->i_sb)->hidden_mnt,
1574 + hidden_flags);
1575 + if (IS_ERR(hidden_file)) {
1576 + err = PTR_ERR(hidden_file);
1577 + dput(hidden_dentry);
1578 + goto out;
1579 + }
1580 + ftohf(file) = hidden_file; /* link two files */
1581 + goto out;
1582 + }
1583 + else {
1584 + if(S_ISDIR(file->f_dentry->d_inode->i_mode)) {
1585 + err = dir_unmod_to_mod(file->f_dentry);
1586 + } else
1587 + err = nondir_unmod_to_mod(file->f_dentry, 1);
1588 +
1589 + if (err) {
1590 + printk("mini_fo_open: ERROR creating storage file.\n");
1591 + goto out;
1592 + }
1593 + }
1594 + }
1595 + hidden_sto_dentry = dtohd2(file->f_dentry);
1596 + dget(hidden_sto_dentry);
1597 +
1598 + if(dtopd(file->f_dentry)->state == MODIFIED) {
1599 + /* Directorys are special, interpose on both lower level files */
1600 + if(S_ISDIR(itohi(inode)->i_mode)) {
1601 + /* check for invalid file types of lower level files */
1602 + if(!(S_ISDIR(itohi(inode)->i_mode) && S_ISDIR(itohi2(inode)->i_mode))) {
1603 + printk(KERN_CRIT "mini_fo_open: meta data corruption detected.\n");
1604 + dput(hidden_sto_dentry);
1605 + err = -EINVAL;
1606 + goto out;
1607 + }
1608 +
1609 + /* lower level directorys are ok, open the base file */
1610 + hidden_dentry = dtohd(file->f_dentry);
1611 + dget(hidden_dentry);
1612 +
1613 + mntget(stopd(inode->i_sb)->hidden_mnt);
1614 + hidden_file = dentry_open(hidden_dentry,
1615 + stopd(inode->i_sb)->hidden_mnt,
1616 + hidden_flags);
1617 + if (IS_ERR(hidden_file)) {
1618 + err = PTR_ERR(hidden_file);
1619 + dput(hidden_dentry);
1620 + dput(hidden_sto_dentry);
1621 + goto out;
1622 + }
1623 + ftohf(file) = hidden_file; /* link the two files */
1624 + }
1625 + }
1626 +
1627 + if(!exists_in_storage(file->f_dentry)) {
1628 + printk(KERN_CRIT "mini_fo_open: invalid file state detected.\n");
1629 + err = -EINVAL;
1630 + dput(hidden_sto_dentry);
1631 +
1632 + /* If the base file has been opened, we need to close it here */
1633 + if(ftohf(file)) {
1634 + if (hidden_file->f_op && hidden_file->f_op->flush)
1635 + hidden_file->f_op->flush(hidden_file);
1636 + dput(hidden_dentry);
1637 + }
1638 + goto out;
1639 + }
1640 +
1641 + /* ok, now we can safely open the storage file */
1642 + mntget(stopd(inode->i_sb)->hidden_mnt2);
1643 + hidden_sto_file = dentry_open(hidden_sto_dentry,
1644 + stopd(inode->i_sb)->hidden_mnt2,
1645 + hidden_flags);
1646 +
1647 + /* dentry_open dputs the dentry if it fails */
1648 + if (IS_ERR(hidden_sto_file)) {
1649 + err = PTR_ERR(hidden_sto_file);
1650 + /* close base file if open */
1651 + if(ftohf(file)) {
1652 + if (hidden_file->f_op && hidden_file->f_op->flush)
1653 + hidden_file->f_op->flush(hidden_file);
1654 + dput(hidden_dentry);
1655 + }
1656 + goto out;
1657 + }
1658 + ftohf2(file) = hidden_sto_file; /* link storage file */
1659 +
1660 + out:
1661 + if (err < 0 && ftopd(file)) {
1662 + kfree(ftopd(file));
1663 + }
1664 + return err;
1665 +}
1666 +
1667 +STATIC int
1668 +mini_fo_flush(file_t *file)
1669 +{
1670 + int err1 = 0; /* assume ok (see open.c:close_fp) */
1671 + int err2 = 0;
1672 + file_t *hidden_file = NULL;
1673 +
1674 + check_mini_fo_file(file);
1675 +
1676 + /* mk: we don't do any state checking here, as its not worth the time.
1677 + * Just flush the lower level files if they exist.
1678 + */
1679 + if(ftopd(file) != NULL) {
1680 + if(ftohf(file) != NULL) {
1681 + hidden_file = ftohf(file);
1682 + if (hidden_file->f_op && hidden_file->f_op->flush)
1683 + err1 = hidden_file->f_op->flush(hidden_file);
1684 + }
1685 + if(ftohf2(file) != NULL) {
1686 + hidden_file = ftohf2(file);
1687 + if (hidden_file->f_op && hidden_file->f_op->flush)
1688 + err2 = hidden_file->f_op->flush(hidden_file);
1689 + }
1690 + }
1691 + return (err1 | err2);
1692 +}
1693 +
1694 +
1695 +STATIC int
1696 +mini_fo_release(inode_t *inode, file_t *file)
1697 +{
1698 + int err = 0;
1699 + file_t *hidden_file = NULL;
1700 +
1701 + if (ftopd(file) != NULL) {
1702 + if(ftohf(file)) {
1703 + hidden_file = ftohf(file);
1704 + fput(hidden_file);
1705 + }
1706 + if(ftohf2(file)) {
1707 + hidden_file = ftohf2(file);
1708 + fput(hidden_file);
1709 + }
1710 + kfree(ftopd(file));
1711 + }
1712 + return err;
1713 +}
1714 +
1715 +STATIC int
1716 +mini_fo_fsync(file_t *file, dentry_t *dentry, int datasync)
1717 +{
1718 + int err1 = 0;
1719 + int err2 = 0;
1720 + file_t *hidden_file = NULL;
1721 + dentry_t *hidden_dentry;
1722 +
1723 + check_mini_fo_file(file);
1724 +
1725 + if ((hidden_file = ftohf(file)) != NULL) {
1726 + hidden_dentry = dtohd(dentry);
1727 + if (hidden_file->f_op && hidden_file->f_op->fsync) {
1728 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
1729 + mutex_lock(&hidden_dentry->d_inode->i_mutex);
1730 +#else
1731 + down(&hidden_dentry->d_inode->i_sem);
1732 +#endif
1733 + err1 = hidden_file->f_op->fsync(hidden_file, hidden_dentry, datasync);
1734 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
1735 + mutex_unlock(&hidden_dentry->d_inode->i_mutex);
1736 +#else
1737 + up(&hidden_dentry->d_inode->i_sem);
1738 +#endif
1739 + }
1740 + }
1741 +
1742 + if ((hidden_file = ftohf2(file)) != NULL) {
1743 + hidden_dentry = dtohd2(dentry);
1744 + if (hidden_file->f_op && hidden_file->f_op->fsync) {
1745 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
1746 + mutex_lock(&hidden_dentry->d_inode->i_mutex);
1747 +#else
1748 + down(&hidden_dentry->d_inode->i_sem);
1749 +#endif
1750 + err2 = hidden_file->f_op->fsync(hidden_file, hidden_dentry, datasync);
1751 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
1752 + mutex_unlock(&hidden_dentry->d_inode->i_mutex);
1753 +#else
1754 + up(&hidden_dentry->d_inode->i_sem);
1755 +#endif
1756 + }
1757 + }
1758 + else
1759 + goto err;
1760 +
1761 +err:
1762 + return (err1 || err2);
1763 +}
1764 +
1765 +
1766 +STATIC int
1767 +mini_fo_fasync(int fd, file_t *file, int flag)
1768 +{
1769 + int err1 = 0;
1770 + int err2 = 0;
1771 +
1772 + file_t *hidden_file = NULL;
1773 +
1774 + check_mini_fo_file(file);
1775 +
1776 + if((hidden_file = ftohf(file)) != NULL) {
1777 + err1 = hidden_file->f_op->fasync(fd, hidden_file, flag);
1778 + }
1779 + if((hidden_file = ftohf2(file)) != NULL) {
1780 + err2 = hidden_file->f_op->fasync(fd, hidden_file, flag);
1781 + }
1782 +
1783 + return (err1 || err2);
1784 +}
1785 +
1786 +
1787 +STATIC int
1788 +mini_fo_lock(file_t *file, int cmd, struct file_lock *fl)
1789 +{
1790 + int err = -EINVAL;
1791 + file_t *hidden_file = NULL;
1792 +
1793 + if(!check_mini_fo_file(file))
1794 + goto out;
1795 +
1796 + /* which file shall we lock? */
1797 + if(ftohf2(file))
1798 + hidden_file = ftohf2(file);
1799 + else
1800 + hidden_file = ftohf(file);
1801 +
1802 + if (hidden_file->f_op->lock) {
1803 + fl->fl_file = hidden_file;
1804 + err = hidden_file->f_op->lock(hidden_file, F_GETLK, fl);
1805 + fl->fl_file = file;
1806 + } else {
1807 + if(posix_test_lock(hidden_file, fl))
1808 + err = 0;
1809 + }
1810 + out:
1811 + return err;
1812 +}
1813 +
1814 +
1815 +struct file_operations mini_fo_dir_fops =
1816 + {
1817 + read: generic_read_dir,
1818 + write: mini_fo_write,
1819 + readdir: mini_fo_readdir,
1820 + poll: mini_fo_poll,
1821 + /* ioctl: mini_fo_ioctl, */
1822 + mmap: mini_fo_mmap,
1823 + open: mini_fo_open,
1824 + flush: mini_fo_flush,
1825 + release: mini_fo_release,
1826 + fsync: mini_fo_fsync,
1827 + fasync: mini_fo_fasync,
1828 + /* not needed lock: mini_fo_lock, */
1829 + /* not needed: readv */
1830 + /* not needed: writev */
1831 + /* not implemented: sendpage */
1832 + /* not implemented: get_unmapped_area */
1833 + };
1834 +
1835 +struct file_operations mini_fo_main_fops =
1836 + {
1837 + llseek: mini_fo_llseek,
1838 + read: mini_fo_read,
1839 + write: mini_fo_write,
1840 + readdir: mini_fo_readdir,
1841 + poll: mini_fo_poll,
1842 + /* ioctl: mini_fo_ioctl, */
1843 + mmap: mini_fo_mmap,
1844 + open: mini_fo_open,
1845 + flush: mini_fo_flush,
1846 + release: mini_fo_release,
1847 + fsync: mini_fo_fsync,
1848 + fasync: mini_fo_fasync,
1849 + /* not needed: lock: mini_fo_lock, */
1850 + /* not needed: readv */
1851 + /* not needed: writev */
1852 + /* not implemented: sendpage */
1853 + /* not implemented: get_unmapped_area */
1854 + };
1855 --- /dev/null
1856 +++ b/fs/mini_fo/fist.h
1857 @@ -0,0 +1,248 @@
1858 +/*
1859 + * Copyright (c) 1997-2003 Erez Zadok
1860 + * Copyright (c) 2001-2003 Stony Brook University
1861 + *
1862 + * For specific licensing information, see the COPYING file distributed with
1863 + * this package, or get one from ftp://ftp.filesystems.org/pub/fist/COPYING.
1864 + *
1865 + * This Copyright notice must be kept intact and distributed with all
1866 + * fistgen sources INCLUDING sources generated by fistgen.
1867 + */
1868 +/*
1869 + * Copyright (C) 2004, 2005 Markus Klotzbuecher <mk@creamnet.de>
1870 + *
1871 + * This program is free software; you can redistribute it and/or
1872 + * modify it under the terms of the GNU General Public License
1873 + * as published by the Free Software Foundation; either version
1874 + * 2 of the License, or (at your option) any later version.
1875 + */
1876 +
1877 +
1878 +/*
1879 + * $Id$
1880 + */
1881 +
1882 +#ifndef __FIST_H_
1883 +#define __FIST_H_
1884 +
1885 +/*
1886 + * KERNEL ONLY CODE:
1887 + */
1888 +#ifdef __KERNEL__
1889 +#include <linux/config.h>
1890 +#include <linux/version.h>
1891 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
1892 +#ifdef CONFIG_MODVERSIONS
1893 +# define MODVERSIONS
1894 +# include <linux/modversions.h>
1895 +#endif /* CONFIG_MODVERSIONS */
1896 +#endif /* KERNEL_VERSION < 2.6.0 */
1897 +#include <linux/sched.h>
1898 +#include <linux/kernel.h>
1899 +#include <linux/mm.h>
1900 +#include <linux/string.h>
1901 +#include <linux/stat.h>
1902 +#include <linux/errno.h>
1903 +#include <linux/wait.h>
1904 +#include <linux/limits.h>
1905 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
1906 +#include <linux/locks.h>
1907 +#else
1908 +#include <linux/buffer_head.h>
1909 +#include <linux/pagemap.h>
1910 +#include <linux/namei.h>
1911 +#include <linux/module.h>
1912 +#include <linux/mount.h>
1913 +#include <linux/page-flags.h>
1914 +#include <linux/writeback.h>
1915 +#include <linux/statfs.h>
1916 +#endif
1917 +#include <linux/smp.h>
1918 +#include <linux/smp_lock.h>
1919 +#include <linux/file.h>
1920 +#include <linux/slab.h>
1921 +#include <linux/vmalloc.h>
1922 +#include <linux/poll.h>
1923 +#include <linux/list.h>
1924 +#include <linux/init.h>
1925 +
1926 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,20)
1927 +#include <linux/xattr.h>
1928 +#endif
1929 +
1930 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
1931 +#include <linux/security.h>
1932 +#endif
1933 +
1934 +#include <linux/swap.h>
1935 +
1936 +#include <asm/system.h>
1937 +#include <asm/segment.h>
1938 +#include <asm/mman.h>
1939 +#include <linux/seq_file.h>
1940 +
1941 +/*
1942 + * MACROS:
1943 + */
1944 +
1945 +/* those mapped to ATTR_* were copied from linux/fs.h */
1946 +#define FA_MODE ATTR_MODE
1947 +#define FA_UID ATTR_UID
1948 +#define FA_GID ATTR_GID
1949 +#define FA_SIZE ATTR_SIZE
1950 +#define FA_ATIME ATTR_ATIME
1951 +#define FA_MTIME ATTR_MTIME
1952 +#define FA_CTIME ATTR_CTIME
1953 +#define FA_ATIME_SET ATTR_ATIME_SET
1954 +#define FA_MTIME_SET ATTR_MTIME_SET
1955 +#define FA_FORCE ATTR_FORCE
1956 +#define FA_ATTR_FLAGS ATTR_ATTR_FLAG
1957 +
1958 +/* must be greater than all other ATTR_* flags! */
1959 +#define FA_NLINK 2048
1960 +#define FA_BLKSIZE 4096
1961 +#define FA_BLOCKS 8192
1962 +#define FA_TIMES (FA_ATIME|FA_MTIME|FA_CTIME)
1963 +#define FA_ALL 0
1964 +
1965 +/* macros to manage changes between kernels */
1966 +#define INODE_DATA(i) (&(i)->i_data)
1967 +
1968 +#define MIN(x,y) ((x < y) ? (x) : (y))
1969 +#define MAX(x,y) ((x > y) ? (x) : (y))
1970 +#define MAXPATHLEN PATH_MAX
1971 +
1972 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,5)
1973 +# define lookup_one_len(a,b,c) lookup_one(a,b)
1974 +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,4,5) */
1975 +
1976 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,8)
1977 +# define generic_file_llseek default_llseek
1978 +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,4,8) */
1979 +
1980 +#ifndef SEEK_SET
1981 +# define SEEK_SET 0
1982 +#endif /* not SEEK_SET */
1983 +
1984 +#ifndef SEEK_CUR
1985 +# define SEEK_CUR 1
1986 +#endif /* not SEEK_CUR */
1987 +
1988 +#ifndef SEEK_END
1989 +# define SEEK_END 2
1990 +#endif /* not SEEK_END */
1991 +
1992 +#ifndef DEFAULT_POLLMASK
1993 +# define DEFAULT_POLLMASK (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM)
1994 +#endif /* not DEFAULT_POLLMASK */
1995 +
1996 +/* XXX: fix this so fistgen generates kfree() code directly */
1997 +#define kfree_s(a,b) kfree(a)
1998 +
1999 +/*
2000 + * TYPEDEFS:
2001 + */
2002 +typedef struct dentry dentry_t;
2003 +typedef struct file file_t;
2004 +typedef struct inode inode_t;
2005 +typedef inode_t vnode_t;
2006 +typedef struct page page_t;
2007 +typedef struct qstr qstr_t;
2008 +typedef struct super_block super_block_t;
2009 +typedef super_block_t vfs_t;
2010 +typedef struct vm_area_struct vm_area_t;
2011 +
2012 +
2013 +/*
2014 + * EXTERNALS:
2015 + */
2016 +
2017 +#define FPPF(str,page) printk("PPF %s 0x%x/%d: Lck:%d Err:%d Ref:%d Upd:%d Other::%d:%d:%d:%d:\n", \
2018 + str, \
2019 + (int) page, \
2020 + (int) page->index, \
2021 + (PageLocked(page) ? 1 : 0), \
2022 + (PageError(page) ? 1 : 0), \
2023 + (PageReferenced(page) ? 1 : 0), \
2024 + (Page_Uptodate(page) ? 1 : 0), \
2025 + (PageDecrAfter(page) ? 1 : 0), \
2026 + (PageSlab(page) ? 1 : 0), \
2027 + (PageSwapCache(page) ? 1 : 0), \
2028 + (PageReserved(page) ? 1 : 0) \
2029 + )
2030 +#define EZKDBG printk("EZK %s:%d:%s\n",__FILE__,__LINE__,__FUNCTION__)
2031 +#if 0
2032 +# define EZKDBG1 printk("EZK %s:%d\n",__FILE__,__LINE__)
2033 +#else
2034 +# define EZKDBG1
2035 +#endif
2036 +
2037 +extern int fist_get_debug_value(void);
2038 +extern int fist_set_debug_value(int val);
2039 +#if 0 /* mini_fo doesn't need these */
2040 +extern void fist_dprint_internal(int level, char *str,...);
2041 +extern void fist_print_dentry(char *str, const dentry_t *dentry);
2042 +extern void fist_print_inode(char *str, const inode_t *inode);
2043 +extern void fist_print_file(char *str, const file_t *file);
2044 +extern void fist_print_buffer_flags(char *str, struct buffer_head *buffer);
2045 +extern void fist_print_page_flags(char *str, page_t *page);
2046 +extern void fist_print_page_bytes(char *str, page_t *page);
2047 +extern void fist_print_pte_flags(char *str, const page_t *page);
2048 +extern void fist_checkinode(inode_t *inode, char *msg);
2049 +extern void fist_print_sb(char *str, const super_block_t *sb);
2050 +
2051 +/* §$% by mk: special debug functions */
2052 +extern void fist_mk_print_dentry(char *str, const dentry_t *dentry);
2053 +extern void fist_mk_print_inode(char *str, const inode_t *inode);
2054 +
2055 +extern char *add_indent(void);
2056 +extern char *del_indent(void);
2057 +#endif/* mini_fo doesn't need these */
2058 +
2059 +
2060 +#define STATIC
2061 +#define ASSERT(EX) \
2062 +do { \
2063 + if (!(EX)) { \
2064 + printk(KERN_CRIT "ASSERTION FAILED: %s at %s:%d (%s)\n", #EX, \
2065 + __FILE__, __LINE__, __FUNCTION__); \
2066 + (*((char *)0))=0; \
2067 + } \
2068 +} while (0)
2069 +/* same ASSERT, but tell me who was the caller of the function */
2070 +#define ASSERT2(EX) \
2071 +do { \
2072 + if (!(EX)) { \
2073 + printk(KERN_CRIT "ASSERTION FAILED (caller): %s at %s:%d (%s)\n", #EX, \
2074 + file, line, func); \
2075 + (*((char *)0))=0; \
2076 + } \
2077 +} while (0)
2078 +
2079 +#if 0 /* mini_fo doesn't need these */
2080 +#define dprintk(format, args...) printk(KERN_DEBUG format, ##args)
2081 +#define fist_dprint(level, str, args...) fist_dprint_internal(level, KERN_DEBUG str, ## args)
2082 +#define print_entry_location() fist_dprint(4, "%sIN: %s %s:%d\n", add_indent(), __FUNCTION__, __FILE__, __LINE__)
2083 +#define print_exit_location() fist_dprint(4, "%s OUT: %s %s:%d\n", del_indent(), __FUNCTION__, __FILE__, __LINE__)
2084 +#define print_exit_status(status) fist_dprint(4, "%s OUT: %s %s:%d, STATUS: %d\n", del_indent(), __FUNCTION__, __FILE__, __LINE__, status)
2085 +#define print_exit_pointer(status) \
2086 +do { \
2087 + if (IS_ERR(status)) \
2088 + fist_dprint(4, "%s OUT: %s %s:%d, RESULT: %ld\n", del_indent(), __FUNCTION__, __FILE__, __LINE__, PTR_ERR(status)); \
2089 + else \
2090 + fist_dprint(4, "%s OUT: %s %s:%d, RESULT: 0x%x\n", del_indent(), __FUNCTION__, __FILE__, __LINE__, PTR_ERR(status)); \
2091 +} while (0)
2092 +#endif/* mini_fo doesn't need these */
2093 +
2094 +#endif /* __KERNEL__ */
2095 +
2096 +
2097 +/*
2098 + * DEFINITIONS FOR USER AND KERNEL CODE:
2099 + * (Note: ioctl numbers 1--9 are reserved for fistgen, the rest
2100 + * are auto-generated automatically based on the user's .fist file.)
2101 + */
2102 +# define FIST_IOCTL_GET_DEBUG_VALUE _IOR(0x15, 1, int)
2103 +# define FIST_IOCTL_SET_DEBUG_VALUE _IOW(0x15, 2, int)
2104 +
2105 +#endif /* not __FIST_H_ */
2106 --- /dev/null
2107 +++ b/fs/mini_fo/inode.c
2108 @@ -0,0 +1,1573 @@
2109 +/*
2110 + * Copyright (c) 1997-2003 Erez Zadok
2111 + * Copyright (c) 2001-2003 Stony Brook University
2112 + *
2113 + * For specific licensing information, see the COPYING file distributed with
2114 + * this package, or get one from ftp://ftp.filesystems.org/pub/fist/COPYING.
2115 + *
2116 + * This Copyright notice must be kept intact and distributed with all
2117 + * fistgen sources INCLUDING sources generated by fistgen.
2118 + */
2119 +/*
2120 + * Copyright (C) 2004, 2005 Markus Klotzbuecher <mk@creamnet.de>
2121 + *
2122 + * This program is free software; you can redistribute it and/or
2123 + * modify it under the terms of the GNU General Public License
2124 + * as published by the Free Software Foundation; either version
2125 + * 2 of the License, or (at your option) any later version.
2126 + */
2127 +
2128 +/*
2129 + * $Id$
2130 + */
2131 +
2132 +#ifdef HAVE_CONFIG_H
2133 +# include <config.h>
2134 +#endif
2135 +
2136 +#include "fist.h"
2137 +#include "mini_fo.h"
2138 +
2139 +STATIC int
2140 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
2141 +mini_fo_create(inode_t *dir, dentry_t *dentry, int mode, struct nameidata *nd)
2142 +#else
2143 +mini_fo_create(inode_t *dir, dentry_t *dentry, int mode)
2144 +#endif
2145 +{
2146 + int err = 0;
2147 +
2148 + check_mini_fo_dentry(dentry);
2149 +
2150 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
2151 + err = create_sto_reg_file(dentry, mode, nd);
2152 +#else
2153 + err = create_sto_reg_file(dentry, mode);
2154 +#endif
2155 + check_mini_fo_dentry(dentry);
2156 + return err;
2157 +}
2158 +
2159 +
2160 +STATIC dentry_t *
2161 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
2162 +mini_fo_lookup(inode_t *dir, dentry_t *dentry, struct nameidata* nd)
2163 +#else
2164 +mini_fo_lookup(inode_t *dir, dentry_t *dentry)
2165 +#endif
2166 +{
2167 + int err = 0;
2168 + dentry_t *hidden_dir_dentry;
2169 + dentry_t *hidden_dentry = NULL;
2170 +
2171 + dentry_t *hidden_sto_dir_dentry;
2172 + dentry_t *hidden_sto_dentry = NULL;
2173 +
2174 + /* whiteout flag */
2175 + int del_flag = 0;
2176 + char *bpath = NULL;
2177 +
2178 + const char *name;
2179 + unsigned int namelen;
2180 +
2181 + /* Don't allow lookups of META-files */
2182 + namelen = strlen(META_FILENAME);
2183 + if(namelen == dentry->d_name.len) {
2184 + if(!strncmp(dentry->d_name.name, META_FILENAME, namelen)) {
2185 + err = -ENOENT;
2186 + goto out;
2187 + }
2188 + }
2189 +
2190 + hidden_dir_dentry = dtohd(dentry->d_parent);
2191 + hidden_sto_dir_dentry = dtohd2(dentry->d_parent);
2192 +
2193 + name = dentry->d_name.name;
2194 + namelen = dentry->d_name.len;
2195 +
2196 + /* must initialize dentry operations */
2197 + dentry->d_op = &mini_fo_dops;
2198 +
2199 + /* setup the del_flag */
2200 + del_flag = __meta_check_d_entry(dir, name, namelen);
2201 + bpath = __meta_check_r_entry(dir, name, namelen);
2202 +
2203 + /* perform the lookups of base and storage files:
2204 + *
2205 + * This caused some serious trouble, as a lookup_one_len passing
2206 + * a negative dentry oopses. Solution is to only do the lookup
2207 + * if the dentry is positive, else we set it to NULL
2208 + * More trouble, who said a *_dir_dentry can't be NULL?
2209 + */
2210 + if(bpath) {
2211 + /* Cross-Interposing (C), yeah! */
2212 + hidden_dentry = bpath_walk(dir->i_sb, bpath);
2213 + if(!hidden_dentry || !hidden_dentry->d_inode) {
2214 + printk(KERN_CRIT "mini_fo_lookup: bpath_walk failed.\n");
2215 + err= -EINVAL;
2216 + goto out;
2217 + }
2218 +
2219 + /* this can be set up safely without fear of spaghetti
2220 + * interposing as it is only used for copying times */
2221 + hidden_dir_dentry = hidden_dentry->d_parent;
2222 + kfree(bpath);
2223 + }
2224 + else if(hidden_dir_dentry && hidden_dir_dentry->d_inode)
2225 + hidden_dentry =
2226 + lookup_one_len(name, hidden_dir_dentry, namelen);
2227 + else
2228 + hidden_dentry = NULL;
2229 +
2230 + if(hidden_sto_dir_dentry && hidden_sto_dir_dentry->d_inode)
2231 + hidden_sto_dentry =
2232 + lookup_one_len(name, hidden_sto_dir_dentry, namelen);
2233 + else
2234 + hidden_sto_dentry = NULL;
2235 +
2236 + /* catch error in lookup */
2237 + if (IS_ERR(hidden_dentry) || IS_ERR(hidden_sto_dentry)) {
2238 + /* mk: we need to call dput on the dentry, whose
2239 + * lookup_one_len operation failed, in order to avoid
2240 + * unmount trouble.
2241 + */
2242 + if(IS_ERR(hidden_dentry)) {
2243 + printk(KERN_CRIT "mini_fo_lookup: ERR from base dentry, lookup failed.\n");
2244 + err = PTR_ERR(hidden_dentry);
2245 + } else {
2246 + dput(hidden_dentry);
2247 + }
2248 + if(IS_ERR(hidden_sto_dentry)) {
2249 + printk(KERN_CRIT "mini_fo_lookup: ERR from storage dentry, lookup failed.\n");
2250 + err = PTR_ERR(hidden_sto_dentry);
2251 + } else {
2252 + dput(hidden_sto_dentry);
2253 + }
2254 + goto out;
2255 + }
2256 +
2257 + /* allocate dentry private data */
2258 + __dtopd(dentry) = (struct mini_fo_dentry_info *)
2259 + kmalloc(sizeof(struct mini_fo_dentry_info), GFP_KERNEL);
2260 +
2261 + if (!dtopd(dentry)) {
2262 + err = -ENOMEM;
2263 + goto out_dput;
2264 + }
2265 +
2266 + /* check for different states of the mini_fo file to be looked up. */
2267 +
2268 + /* state 1, file has been modified */
2269 + if(hidden_dentry && hidden_sto_dentry &&
2270 + hidden_dentry->d_inode && hidden_sto_dentry->d_inode && !del_flag) {
2271 +
2272 + /* update parent directory's atime */
2273 + fist_copy_attr_atime(dir, hidden_sto_dir_dentry->d_inode);
2274 +
2275 + dtopd(dentry)->state = MODIFIED;
2276 + dtohd(dentry) = hidden_dentry;
2277 + dtohd2(dentry) = hidden_sto_dentry;
2278 +
2279 + err = mini_fo_tri_interpose(hidden_dentry,
2280 + hidden_sto_dentry,
2281 + dentry, dir->i_sb, 1);
2282 + if (err) {
2283 + printk(KERN_CRIT "mini_fo_lookup: error interposing (state1).\n");
2284 + goto out_free;
2285 + }
2286 + goto out;
2287 + }
2288 + /* state 2, file is unmodified */
2289 + if(hidden_dentry && hidden_dentry->d_inode && !del_flag) {
2290 +
2291 + fist_copy_attr_atime(dir, hidden_dir_dentry->d_inode);
2292 +
2293 + dtopd(dentry)->state = UNMODIFIED;
2294 + dtohd(dentry) = hidden_dentry;
2295 + dtohd2(dentry) = hidden_sto_dentry; /* could be negative */
2296 +
2297 + err = mini_fo_tri_interpose(hidden_dentry,
2298 + hidden_sto_dentry,
2299 + dentry, dir->i_sb, 1);
2300 + if (err) {
2301 + printk(KERN_CRIT "mini_fo_lookup: error interposing (state2).\n");
2302 + goto out_free;
2303 + }
2304 + goto out;
2305 + }
2306 + /* state 3, file has been newly created */
2307 + if(hidden_sto_dentry && hidden_sto_dentry->d_inode && !del_flag) {
2308 +
2309 + fist_copy_attr_atime(dir, hidden_sto_dir_dentry->d_inode);
2310 + dtopd(dentry)->state = CREATED;
2311 + dtohd(dentry) = hidden_dentry; /* could be negative */
2312 + dtohd2(dentry) = hidden_sto_dentry;
2313 +
2314 + err = mini_fo_tri_interpose(hidden_dentry,
2315 + hidden_sto_dentry,
2316 + dentry, dir->i_sb, 1);
2317 + if (err) {
2318 + printk(KERN_CRIT "mini_fo_lookup: error interposing (state3).\n");
2319 + goto out_free;
2320 + }
2321 + goto out;
2322 + }
2323 +
2324 + /* state 4, file has deleted and created again. */
2325 + if(hidden_dentry && hidden_sto_dentry &&
2326 + hidden_dentry->d_inode &&
2327 + hidden_sto_dentry->d_inode && del_flag) {
2328 +
2329 + fist_copy_attr_atime(dir, hidden_sto_dir_dentry->d_inode);
2330 + dtopd(dentry)->state = DEL_REWRITTEN;
2331 + dtohd(dentry) = NULL;
2332 + dtohd2(dentry) = hidden_sto_dentry;
2333 +
2334 + err = mini_fo_tri_interpose(NULL,
2335 + hidden_sto_dentry,
2336 + dentry, dir->i_sb, 1);
2337 + if (err) {
2338 + printk(KERN_CRIT "mini_fo_lookup: error interposing (state4).\n");
2339 + goto out_free;
2340 + }
2341 + /* We will never need this dentry again, as the file has been
2342 + * deleted from base */
2343 + dput(hidden_dentry);
2344 + goto out;
2345 + }
2346 + /* state 5, file has been deleted in base */
2347 + if(hidden_dentry && hidden_sto_dentry &&
2348 + hidden_dentry->d_inode &&
2349 + !hidden_sto_dentry->d_inode && del_flag) {
2350 +
2351 + /* check which parents atime we need for updating */
2352 + if(hidden_sto_dir_dentry->d_inode)
2353 + fist_copy_attr_atime(dir,
2354 + hidden_sto_dir_dentry->d_inode);
2355 + else
2356 + fist_copy_attr_atime(dir,
2357 + hidden_dir_dentry->d_inode);
2358 +
2359 + dtopd(dentry)->state = DELETED;
2360 + dtohd(dentry) = NULL;
2361 + dtohd2(dentry) = hidden_sto_dentry;
2362 +
2363 + /* add negative dentry to dcache to speed up lookups */
2364 + d_add(dentry, NULL);
2365 + dput(hidden_dentry);
2366 + goto out;
2367 + }
2368 + /* state 6, file does not exist */
2369 + if(((hidden_dentry && !hidden_dentry->d_inode) ||
2370 + (hidden_sto_dentry && !hidden_sto_dentry->d_inode)) && !del_flag)
2371 + {
2372 + /* check which parents atime we need for updating */
2373 + if(hidden_sto_dir_dentry && hidden_sto_dir_dentry->d_inode)
2374 + fist_copy_attr_atime(dir, hidden_sto_dir_dentry->d_inode);
2375 + else
2376 + fist_copy_attr_atime(dir, hidden_dir_dentry->d_inode);
2377 +
2378 + dtopd(dentry)->state = NON_EXISTANT;
2379 + dtohd(dentry) = hidden_dentry;
2380 + dtohd2(dentry) = hidden_sto_dentry;
2381 + d_add(dentry, NULL);
2382 + goto out;
2383 + }
2384 +
2385 + /* if we get to here, were in an invalid state. bad. */
2386 + printk(KERN_CRIT "mini_fo_lookup: ERROR, meta data corruption detected.\n");
2387 +
2388 + /* end state checking */
2389 + out_free:
2390 + d_drop(dentry); /* so that our bad dentry will get destroyed */
2391 + kfree(dtopd(dentry));
2392 + __dtopd(dentry) = NULL; /* be safe */
2393 +
2394 + out_dput:
2395 + if(hidden_dentry)
2396 + dput(hidden_dentry);
2397 + if(hidden_sto_dentry)
2398 + dput(hidden_sto_dentry); /* drops usage count and marks for release */
2399 +
2400 + out:
2401 + /* initalize wol if file exists and is directory */
2402 + if(dentry->d_inode) {
2403 + if(S_ISDIR(dentry->d_inode->i_mode)) {
2404 + itopd(dentry->d_inode)->deleted_list_size = -1;
2405 + itopd(dentry->d_inode)->renamed_list_size = -1;
2406 + meta_build_lists(dentry);
2407 + }
2408 + }
2409 + return ERR_PTR(err);
2410 +}
2411 +
2412 +
2413 +STATIC int
2414 +mini_fo_link(dentry_t *old_dentry, inode_t *dir, dentry_t *new_dentry)
2415 +{
2416 + int err;
2417 + dentry_t *hidden_old_dentry;
2418 + dentry_t *hidden_new_dentry;
2419 + dentry_t *hidden_dir_dentry;
2420 +
2421 +
2422 + check_mini_fo_dentry(old_dentry);
2423 + check_mini_fo_dentry(new_dentry);
2424 + check_mini_fo_inode(dir);
2425 +
2426 + /* no links to directorys and existing targets target allowed */
2427 + if(S_ISDIR(old_dentry->d_inode->i_mode) ||
2428 + is_mini_fo_existant(new_dentry)) {
2429 + err = -EPERM;
2430 + goto out;
2431 + }
2432 +
2433 + /* bring it directly from unmod to del_rew */
2434 + if(dtost(old_dentry) == UNMODIFIED) {
2435 + err = nondir_unmod_to_mod(old_dentry, 1);
2436 + if(err) {
2437 + err = -EINVAL;
2438 + goto out;
2439 + }
2440 + err = meta_add_d_entry(old_dentry->d_parent,
2441 + old_dentry->d_name.name,
2442 + old_dentry->d_name.len);
2443 + if(err) {
2444 + err = -EINVAL;
2445 + goto out;
2446 + }
2447 + dput(dtohd(old_dentry));
2448 + dtohd(old_dentry) = NULL;
2449 + dtost(old_dentry) = DEL_REWRITTEN;
2450 + }
2451 +
2452 + err = get_neg_sto_dentry(new_dentry);
2453 + if(err) {
2454 + err = -EINVAL;
2455 + goto out;
2456 + }
2457 +
2458 + hidden_old_dentry = dtohd2(old_dentry);
2459 + hidden_new_dentry = dtohd2(new_dentry);
2460 +
2461 + dget(hidden_old_dentry);
2462 + dget(hidden_new_dentry);
2463 +
2464 + /* was: hidden_dir_dentry = lock_parent(hidden_new_dentry); */
2465 + hidden_dir_dentry = dget(hidden_new_dentry->d_parent);
2466 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
2467 + mutex_lock(&hidden_dir_dentry->d_inode->i_mutex);
2468 +#else
2469 + down(&hidden_dir_dentry->d_inode->i_sem);
2470 +#endif
2471 +
2472 + err = vfs_link(hidden_old_dentry,
2473 + hidden_dir_dentry->d_inode,
2474 + hidden_new_dentry);
2475 + if (err || !hidden_new_dentry->d_inode)
2476 + goto out_lock;
2477 +
2478 + dtost(new_dentry) = CREATED;
2479 + err = mini_fo_tri_interpose(NULL, hidden_new_dentry, new_dentry, dir->i_sb, 0);
2480 + if (err)
2481 + goto out_lock;
2482 +
2483 + fist_copy_attr_timesizes(dir, hidden_new_dentry->d_inode);
2484 + /* propagate number of hard-links */
2485 + old_dentry->d_inode->i_nlink = itohi2(old_dentry->d_inode)->i_nlink;
2486 +
2487 + out_lock:
2488 + /* was: unlock_dir(hidden_dir_dentry); */
2489 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
2490 + mutex_unlock(&hidden_dir_dentry->d_inode->i_mutex);
2491 +#else
2492 + up(&hidden_dir_dentry->d_inode->i_sem);
2493 +#endif
2494 + dput(hidden_dir_dentry);
2495 +
2496 + dput(hidden_new_dentry);
2497 + dput(hidden_old_dentry);
2498 + if (!new_dentry->d_inode)
2499 + d_drop(new_dentry);
2500 +
2501 + out:
2502 + return err;
2503 +}
2504 +
2505 +
2506 +STATIC int
2507 +mini_fo_unlink(inode_t *dir, dentry_t *dentry)
2508 +{
2509 + int err = 0;
2510 +
2511 + dget(dentry);
2512 + if(dtopd(dentry)->state == MODIFIED) {
2513 + err = nondir_mod_to_del(dentry);
2514 + goto out;
2515 + }
2516 + else if(dtopd(dentry)->state == UNMODIFIED) {
2517 + err = nondir_unmod_to_del(dentry);
2518 + goto out;
2519 + }
2520 + else if(dtopd(dentry)->state == CREATED) {
2521 + err = nondir_creat_to_del(dentry);
2522 + goto out;
2523 + }
2524 + else if(dtopd(dentry)->state == DEL_REWRITTEN) {
2525 + err = nondir_del_rew_to_del(dentry);
2526 + goto out;
2527 + }
2528 +
2529 + printk(KERN_CRIT "mini_fo_unlink: ERROR, invalid state detected.\n");
2530 +
2531 + out:
2532 + fist_copy_attr_times(dir, itohi2(dentry->d_parent->d_inode));
2533 +
2534 + if(!err) {
2535 + /* is this causing my pain? d_delete(dentry); */
2536 + d_drop(dentry);
2537 + }
2538 +
2539 + dput(dentry);
2540 + return err;
2541 +}
2542 +
2543 +
2544 +STATIC int
2545 +mini_fo_symlink(inode_t *dir, dentry_t *dentry, const char *symname)
2546 +{
2547 + int err=0;
2548 + dentry_t *hidden_sto_dentry;
2549 + dentry_t *hidden_sto_dir_dentry;
2550 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
2551 + umode_t mode;
2552 +#endif
2553 +
2554 + /* Fail if the symlink file exists */
2555 + if(!(dtost(dentry) == DELETED ||
2556 + dtost(dentry) == NON_EXISTANT)) {
2557 + err = -EEXIST;
2558 + goto out;
2559 + }
2560 +
2561 + err = get_neg_sto_dentry(dentry);
2562 + if(err) {
2563 + err = -EINVAL;
2564 + goto out;
2565 + }
2566 + hidden_sto_dentry = dtohd2(dentry);
2567 +
2568 + dget(hidden_sto_dentry);
2569 + /* was: hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry); */
2570 + hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
2571 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
2572 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
2573 +#else
2574 + down(&hidden_sto_dir_dentry->d_inode->i_sem);
2575 +#endif
2576 +
2577 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
2578 + mode = S_IALLUGO;
2579 + err = vfs_symlink(hidden_sto_dir_dentry->d_inode,
2580 + hidden_sto_dentry, symname, mode);
2581 +#else
2582 + err = vfs_symlink(hidden_sto_dir_dentry->d_inode,
2583 + hidden_sto_dentry,
2584 + symname);
2585 +#endif
2586 + if (err || !hidden_sto_dentry->d_inode)
2587 + goto out_lock;
2588 +
2589 + if(dtost(dentry) == DELETED) {
2590 + dtost(dentry) = DEL_REWRITTEN;
2591 + err = mini_fo_tri_interpose(NULL, hidden_sto_dentry, dentry, dir->i_sb, 0);
2592 + if(err)
2593 + goto out_lock;
2594 + } else if(dtost(dentry) == NON_EXISTANT) {
2595 + dtost(dentry) = CREATED;
2596 + err = mini_fo_tri_interpose(dtohd(dentry), hidden_sto_dentry, dentry, dir->i_sb, 0);
2597 + if(err)
2598 + goto out_lock;
2599 + }
2600 + fist_copy_attr_timesizes(dir, hidden_sto_dir_dentry->d_inode);
2601 +
2602 + out_lock:
2603 + /* was: unlock_dir(hidden_sto_dir_dentry); */
2604 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
2605 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
2606 +#else
2607 + up(&hidden_sto_dir_dentry->d_inode->i_sem);
2608 +#endif
2609 + dput(hidden_sto_dir_dentry);
2610 +
2611 + dput(hidden_sto_dentry);
2612 + if (!dentry->d_inode)
2613 + d_drop(dentry);
2614 + out:
2615 + return err;
2616 +}
2617 +
2618 +STATIC int
2619 +mini_fo_mkdir(inode_t *dir, dentry_t *dentry, int mode)
2620 +{
2621 + int err;
2622 +
2623 + err = create_sto_dir(dentry, mode);
2624 +
2625 + check_mini_fo_dentry(dentry);
2626 +
2627 + return err;
2628 +}
2629 +
2630 +
2631 +STATIC int
2632 +mini_fo_rmdir(inode_t *dir, dentry_t *dentry)
2633 +{
2634 + int err = 0;
2635 +
2636 + dentry_t *hidden_sto_dentry;
2637 + dentry_t *hidden_sto_dir_dentry;
2638 + dentry_t *meta_dentry;
2639 + inode_t *hidden_sto_dir = NULL;
2640 +
2641 + check_mini_fo_dentry(dentry);
2642 + check_mini_fo_inode(dir);
2643 +
2644 + dget(dentry);
2645 + if(dtopd(dentry)->state == MODIFIED) {
2646 + /* XXX: disabled, because it does not bother to check files on
2647 + * the original filesystem - just a hack, but better than simply
2648 + * removing it without testing */
2649 + err = -EINVAL;
2650 + goto out;
2651 +
2652 + hidden_sto_dir = itohi2(dir);
2653 + hidden_sto_dentry = dtohd2(dentry);
2654 +
2655 + /* was:hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry); */
2656 + hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
2657 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
2658 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
2659 +#else
2660 + down(&hidden_sto_dir_dentry->d_inode->i_sem);
2661 +#endif
2662 +
2663 + /* avoid destroying the hidden inode if the file is in use */
2664 + dget(hidden_sto_dentry);
2665 +
2666 + /* Delete an old WOL file contained in the storage dir */
2667 + meta_dentry = lookup_one_len(META_FILENAME,
2668 + hidden_sto_dentry,
2669 + strlen(META_FILENAME));
2670 + if(meta_dentry->d_inode) {
2671 + err = vfs_unlink(hidden_sto_dentry->d_inode, meta_dentry);
2672 + dput(meta_dentry);
2673 + if(!err)
2674 + d_delete(meta_dentry);
2675 + }
2676 +
2677 + err = vfs_rmdir(hidden_sto_dir, hidden_sto_dentry);
2678 + dput(hidden_sto_dentry);
2679 + if(!err)
2680 + d_delete(hidden_sto_dentry);
2681 +
2682 + /* propagate number of hard-links */
2683 + dentry->d_inode->i_nlink = itohi2(dentry->d_inode)->i_nlink;
2684 +
2685 + dput(dtohd(dentry));
2686 +
2687 + dtohd(dentry) = NULL;
2688 + dtopd(dentry)->state = DELETED;
2689 +
2690 + /* carefull with R files */
2691 + if( __meta_is_r_entry(dir,
2692 + dentry->d_name.name,
2693 + dentry->d_name.len) == 1) {
2694 + err = meta_remove_r_entry(dentry->d_parent,
2695 + dentry->d_name.name,
2696 + dentry->d_name.len);
2697 + if(err) {
2698 + printk(KERN_CRIT "mini_fo: rmdir: meta_remove_r_entry failed.\n");
2699 + goto out;
2700 + }
2701 + }
2702 + else {
2703 + /* ok, add deleted file to META */
2704 + meta_add_d_entry(dentry->d_parent,
2705 + dentry->d_name.name,
2706 + dentry->d_name.len);
2707 + }
2708 + /* was: unlock_dir(hidden_sto_dir_dentry); */
2709 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
2710 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
2711 +#else
2712 + up(&hidden_sto_dir_dentry->d_inode->i_sem);
2713 +#endif
2714 + dput(hidden_sto_dir_dentry);
2715 + goto out;
2716 + }
2717 + else if(dtopd(dentry)->state == UNMODIFIED) {
2718 + /* XXX: simply adding it to the delete list here is fscking dangerous!
2719 + * as a temporary hack, i will disable rmdir on unmodified directories
2720 + * for now.
2721 + */
2722 + err = -EINVAL;
2723 + goto out;
2724 +
2725 + err = get_neg_sto_dentry(dentry);
2726 + if(err) {
2727 + err = -EINVAL;
2728 + goto out;
2729 + }
2730 +
2731 + /* dput base dentry, this will relase the inode and free the
2732 + * dentry, as we will never need it again. */
2733 + dput(dtohd(dentry));
2734 + dtohd(dentry) = NULL;
2735 + dtopd(dentry)->state = DELETED;
2736 +
2737 + /* add deleted file to META-file */
2738 + meta_add_d_entry(dentry->d_parent,
2739 + dentry->d_name.name,
2740 + dentry->d_name.len);
2741 + goto out;
2742 + }
2743 + else if(dtopd(dentry)->state == CREATED) {
2744 + hidden_sto_dir = itohi2(dir);
2745 + hidden_sto_dentry = dtohd2(dentry);
2746 +
2747 + /* was: hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry);*/
2748 + hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
2749 +
2750 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
2751 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
2752 +#else
2753 + down(&hidden_sto_dir_dentry->d_inode->i_sem);
2754 +#endif
2755 +
2756 + /* avoid destroying the hidden inode if the file is in use */
2757 + dget(hidden_sto_dentry);
2758 +
2759 + /* Delete an old WOL file contained in the storage dir */
2760 + meta_dentry = lookup_one_len(META_FILENAME,
2761 + hidden_sto_dentry,
2762 + strlen(META_FILENAME));
2763 + if(meta_dentry->d_inode) {
2764 + /* is this necessary? dget(meta_dentry); */
2765 + err = vfs_unlink(hidden_sto_dentry->d_inode,
2766 + meta_dentry);
2767 + dput(meta_dentry);
2768 + if(!err)
2769 + d_delete(meta_dentry);
2770 + }
2771 +
2772 + err = vfs_rmdir(hidden_sto_dir, hidden_sto_dentry);
2773 + dput(hidden_sto_dentry);
2774 + if(!err)
2775 + d_delete(hidden_sto_dentry);
2776 +
2777 + /* propagate number of hard-links */
2778 + dentry->d_inode->i_nlink = itohi2(dentry->d_inode)->i_nlink;
2779 + dtopd(dentry)->state = NON_EXISTANT;
2780 +
2781 + /* was: unlock_dir(hidden_sto_dir_dentry); */
2782 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
2783 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
2784 +#else
2785 + up(&hidden_sto_dir_dentry->d_inode->i_sem);
2786 +#endif
2787 + dput(hidden_sto_dir_dentry);
2788 +
2789 + goto out;
2790 + }
2791 + else if(dtopd(dentry)->state == DEL_REWRITTEN) {
2792 + hidden_sto_dir = itohi2(dir);
2793 + hidden_sto_dentry = dtohd2(dentry);
2794 +
2795 + /* was: hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry);*/
2796 + hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
2797 +
2798 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
2799 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
2800 +#else
2801 + down(&hidden_sto_dir_dentry->d_inode->i_sem);
2802 +#endif
2803 +
2804 + /* avoid destroying the hidden inode if the file is in use */
2805 + dget(hidden_sto_dentry);
2806 +
2807 + /* Delete an old WOL file contained in the storage dir */
2808 + meta_dentry = lookup_one_len(META_FILENAME,
2809 + hidden_sto_dentry,
2810 + strlen(META_FILENAME));
2811 + if(meta_dentry->d_inode) {
2812 + /* is this necessary? dget(meta_dentry); */
2813 + err = vfs_unlink(hidden_sto_dentry->d_inode,
2814 + meta_dentry);
2815 + dput(meta_dentry);
2816 + if(!err)
2817 + d_delete(meta_dentry);
2818 + }
2819 +
2820 + err = vfs_rmdir(hidden_sto_dir, hidden_sto_dentry);
2821 + dput(hidden_sto_dentry);
2822 + if(!err)
2823 + d_delete(hidden_sto_dentry);
2824 +
2825 + /* propagate number of hard-links */
2826 + dentry->d_inode->i_nlink = itohi2(dentry->d_inode)->i_nlink;
2827 + dtopd(dentry)->state = DELETED;
2828 + /* was: unlock_dir(hidden_sto_dir_dentry); */
2829 +
2830 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
2831 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
2832 +#else
2833 + up(&hidden_sto_dir_dentry->d_inode->i_sem);
2834 +#endif
2835 + dput(hidden_sto_dir_dentry);
2836 + goto out;
2837 + }
2838 +
2839 + printk(KERN_CRIT "mini_fo_rmdir: ERROR, invalid state detected.\n");
2840 +
2841 + out:
2842 + if(!err) {
2843 + d_drop(dentry);
2844 + }
2845 +
2846 + fist_copy_attr_times(dir, itohi2(dentry->d_parent->d_inode));
2847 + dput(dentry);
2848 +
2849 + return err;
2850 +}
2851 +
2852 +
2853 +STATIC int
2854 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
2855 +mini_fo_mknod(inode_t *dir, dentry_t *dentry, int mode, dev_t dev)
2856 +#else
2857 +mini_fo_mknod(inode_t *dir, dentry_t *dentry, int mode, int dev)
2858 +#endif
2859 +{
2860 + int err = 0;
2861 +
2862 + check_mini_fo_dentry(dentry);
2863 +
2864 + err = create_sto_nod(dentry, mode, dev);
2865 + if(err) {
2866 + printk(KERN_CRIT "mini_fo_mknod: creating sto nod failed.\n");
2867 + err = -EINVAL;
2868 + }
2869 +
2870 + check_mini_fo_dentry(dentry);
2871 + return err;
2872 +}
2873 +
2874 +
2875 +STATIC int
2876 +mini_fo_rename(inode_t *old_dir, dentry_t *old_dentry,
2877 + inode_t *new_dir, dentry_t *new_dentry)
2878 +{
2879 + /* dispatch */
2880 + if(S_ISDIR(old_dentry->d_inode->i_mode))
2881 + return rename_directory(old_dir, old_dentry, new_dir, new_dentry);
2882 + return rename_nondir(old_dir, old_dentry, new_dir, new_dentry);
2883 +
2884 +}
2885 +
2886 +int rename_directory(inode_t *old_dir, dentry_t *old_dentry,
2887 + inode_t *new_dir, dentry_t *new_dentry)
2888 +{
2889 + int err, bpath_len;
2890 + char *bpath;
2891 +
2892 + dentry_t *hidden_old_dentry;
2893 + dentry_t *hidden_new_dentry;
2894 + dentry_t *hidden_old_dir_dentry;
2895 + dentry_t *hidden_new_dir_dentry;
2896 +
2897 + err = 0;
2898 + bpath = NULL;
2899 + bpath_len = 0;
2900 +
2901 + /* this is a test, chuck out if it works */
2902 + if(!(dtopd(new_dentry)->state == DELETED ||
2903 + dtopd(new_dentry)->state == NON_EXISTANT)) {
2904 + printk(KERN_CRIT "mini_fo: rename_directory: \
2905 + uh, ah, new_dentry not negative.\n");
2906 + /* return -1; */
2907 + }
2908 +
2909 + /* state = UNMODIFIED */
2910 + if(dtopd(old_dentry)->state == UNMODIFIED) {
2911 + err = dir_unmod_to_mod(old_dentry);
2912 + if (err)
2913 + goto out;
2914 + }
2915 +
2916 + /* state = MODIFIED */
2917 + if(dtopd(old_dentry)->state == MODIFIED) {
2918 + bpath = meta_check_r_entry(old_dentry->d_parent,
2919 + old_dentry->d_name.name,
2920 + old_dentry->d_name.len);
2921 + if(bpath) {
2922 + err = meta_remove_r_entry(old_dentry->d_parent,
2923 + old_dentry->d_name.name,
2924 + old_dentry->d_name.len);
2925 + if(err) {
2926 + printk(KERN_CRIT "mini_fo: rename_directory:\
2927 + meta_remove_r_entry \
2928 + failed.\n");
2929 + goto out;
2930 + }
2931 + err = meta_add_r_entry(new_dentry->d_parent,
2932 + bpath,
2933 + strlen(bpath),
2934 + new_dentry->d_name.name,
2935 + new_dentry->d_name.len);
2936 + kfree(bpath);
2937 + }
2938 + else {/* wol it */
2939 + err = meta_add_d_entry(old_dentry->d_parent,
2940 + old_dentry->d_name.name,
2941 + old_dentry->d_name.len);
2942 + if (err)
2943 + goto out;
2944 + /* put it on rename list */
2945 + err = get_mini_fo_bpath(old_dentry,
2946 + &bpath,
2947 + &bpath_len);
2948 + if (err)
2949 + goto out;
2950 + err = meta_add_r_entry(new_dentry->d_parent,
2951 + bpath, bpath_len,
2952 + new_dentry->d_name.name,
2953 + new_dentry->d_name.len);
2954 + if (err)
2955 + goto out;
2956 + }
2957 + /* no state change, MODIFIED stays MODIFIED */
2958 + }
2959 + /* state = CREATED */
2960 + if(dtopd(old_dentry)->state == CREATED ||
2961 + dtopd(old_dentry)->state == DEL_REWRITTEN) {
2962 + if(dtohd(old_dentry))
2963 + dput(dtohd(old_dentry));
2964 +
2965 + if(dtopd(new_dentry)->state == DELETED) {
2966 + dtopd(old_dentry)->state = DEL_REWRITTEN;
2967 + dtohd(old_dentry) = NULL;
2968 + }
2969 + else if(dtopd(new_dentry)->state == NON_EXISTANT) {
2970 + dtopd(old_dentry)->state = CREATED;
2971 + /* steal new dentry's neg. base dentry */
2972 + dtohd(old_dentry) = dtohd(new_dentry);
2973 + dtohd(new_dentry) = NULL;
2974 + }
2975 + }
2976 + if(dtopd(new_dentry)->state == UNMODIFIED ||
2977 + dtopd(new_dentry)->state == NON_EXISTANT) {
2978 + err = get_neg_sto_dentry(new_dentry);
2979 + if(err)
2980 + goto out;
2981 + }
2982 +
2983 + /* now move sto file */
2984 + hidden_old_dentry = dtohd2(old_dentry);
2985 + hidden_new_dentry = dtohd2(new_dentry);
2986 +
2987 + dget(hidden_old_dentry);
2988 + dget(hidden_new_dentry);
2989 +
2990 + hidden_old_dir_dentry = dget(hidden_old_dentry->d_parent);
2991 + hidden_new_dir_dentry = dget(hidden_new_dentry->d_parent);
2992 + double_lock(hidden_old_dir_dentry, hidden_new_dir_dentry);
2993 +
2994 + err = vfs_rename(hidden_old_dir_dentry->d_inode, hidden_old_dentry,
2995 + hidden_new_dir_dentry->d_inode, hidden_new_dentry);
2996 + if(err)
2997 + goto out_lock;
2998 +
2999 + fist_copy_attr_all(new_dir, hidden_new_dir_dentry->d_inode);
3000 + if (new_dir != old_dir)
3001 + fist_copy_attr_all(old_dir,
3002 + hidden_old_dir_dentry->d_inode);
3003 +
3004 + out_lock:
3005 + /* double_unlock will dput the new/old parent dentries
3006 + * whose refcnts were incremented via get_parent above. */
3007 + double_unlock(hidden_old_dir_dentry, hidden_new_dir_dentry);
3008 + dput(hidden_new_dentry);
3009 + dput(hidden_old_dentry);
3010 +
3011 + out:
3012 + return err;
3013 +}
3014 +
3015 +int rename_nondir(inode_t *old_dir, dentry_t *old_dentry,
3016 + inode_t *new_dir, dentry_t *new_dentry)
3017 +{
3018 + int err=0;
3019 +
3020 + check_mini_fo_dentry(old_dentry);
3021 + check_mini_fo_dentry(new_dentry);
3022 + check_mini_fo_inode(old_dir);
3023 + check_mini_fo_inode(new_dir);
3024 +
3025 + /* state: UNMODIFIED */
3026 + if(dtost(old_dentry) == UNMODIFIED) {
3027 + err = nondir_unmod_to_mod(old_dentry, 1);
3028 + if(err) {
3029 + err = -EINVAL;
3030 + goto out;
3031 + }
3032 + }
3033 +
3034 + /* the easy states */
3035 + if(exists_in_storage(old_dentry)) {
3036 +
3037 + dentry_t *hidden_old_dentry;
3038 + dentry_t *hidden_new_dentry;
3039 + dentry_t *hidden_old_dir_dentry;
3040 + dentry_t *hidden_new_dir_dentry;
3041 +
3042 + /* if old file is MODIFIED, add it to the deleted_list */
3043 + if(dtopd(old_dentry)->state == MODIFIED) {
3044 + meta_add_d_entry(old_dentry->d_parent,
3045 + old_dentry->d_name.name,
3046 + old_dentry->d_name.len);
3047 +
3048 + dput(dtohd(old_dentry));
3049 + }
3050 + /* if old file is CREATED, we only release the base dentry */
3051 + if(dtopd(old_dentry)->state == CREATED) {
3052 + if(dtohd(old_dentry))
3053 + dput(dtohd(old_dentry));
3054 + }
3055 +
3056 + /* now setup the new states (depends on new_dentry state) */
3057 + /* new dentry state = MODIFIED */
3058 + if(dtopd(new_dentry)->state == MODIFIED) {
3059 + meta_add_d_entry(new_dentry->d_parent,
3060 + new_dentry->d_name.name,
3061 + new_dentry->d_name.len);
3062 +
3063 + /* new dentry will be d_put'ed later by the vfs
3064 + * so don't do it here
3065 + * dput(dtohd(new_dentry));
3066 + */
3067 + dtohd(old_dentry) = NULL;
3068 + dtopd(old_dentry)->state = DEL_REWRITTEN;
3069 + }
3070 + /* new dentry state = UNMODIFIED */
3071 + else if(dtopd(new_dentry)->state == UNMODIFIED) {
3072 + if(get_neg_sto_dentry(new_dentry))
3073 + return -EINVAL;
3074 +
3075 + meta_add_d_entry(new_dentry->d_parent,
3076 + new_dentry->d_name.name,
3077 + new_dentry->d_name.len);
3078 +
3079 + /* is this right??? */
3080 + /*dput(dtohd(new_dentry));*/
3081 + dtohd(old_dentry) = NULL;
3082 + dtopd(old_dentry)->state = DEL_REWRITTEN;
3083 + }
3084 + /* new dentry state = CREATED */
3085 + else if(dtopd(new_dentry)->state == CREATED) {
3086 + /* we keep the neg. base dentry (if exists) */
3087 + dtohd(old_dentry) = dtohd(new_dentry);
3088 + /* ...and set it to Null, or we'll get
3089 + * dcache.c:345 if it gets dput twice... */
3090 + dtohd(new_dentry) = NULL;
3091 + dtopd(old_dentry)->state = CREATED;
3092 + }
3093 + /* new dentry state = NON_EXISTANT */
3094 + else if(dtopd(new_dentry)->state == NON_EXISTANT) {
3095 + if(get_neg_sto_dentry(new_dentry))
3096 + return -EINVAL;
3097 +
3098 + /* we keep the neg. base dentry (if exists) */
3099 + dtohd(old_dentry) = dtohd(new_dentry);
3100 + /* ...and set it to Null, or we'll get
3101 + * Dr. dcache.c:345 if it gets dput twice... */
3102 + dtohd(new_dentry) = NULL;
3103 + dtopd(old_dentry)->state = CREATED;
3104 + }
3105 + /* new dentry state = DEL_REWRITTEN or DELETED */
3106 + else if(dtopd(new_dentry)->state == DEL_REWRITTEN ||
3107 + dtopd(new_dentry)->state == DELETED) {
3108 + dtohd(old_dentry) = NULL;
3109 + dtopd(old_dentry)->state = DEL_REWRITTEN;
3110 + }
3111 + else { /* not possible, uhh, ahh */
3112 + printk(KERN_CRIT
3113 + "mini_fo: rename_reg_file: invalid state detected [1].\n");
3114 + return -1;
3115 + }
3116 +
3117 + /* now we definitely have a sto file */
3118 + hidden_old_dentry = dtohd2(old_dentry);
3119 + hidden_new_dentry = dtohd2(new_dentry);
3120 +
3121 + dget(hidden_old_dentry);
3122 + dget(hidden_new_dentry);
3123 +
3124 + hidden_old_dir_dentry = dget(hidden_old_dentry->d_parent);
3125 + hidden_new_dir_dentry = dget(hidden_new_dentry->d_parent);
3126 + double_lock(hidden_old_dir_dentry, hidden_new_dir_dentry);
3127 +
3128 + err = vfs_rename(hidden_old_dir_dentry->d_inode,
3129 + hidden_old_dentry,
3130 + hidden_new_dir_dentry->d_inode,
3131 + hidden_new_dentry);
3132 + if(err)
3133 + goto out_lock;
3134 +
3135 + fist_copy_attr_all(new_dir, hidden_new_dir_dentry->d_inode);
3136 + if (new_dir != old_dir)
3137 + fist_copy_attr_all(old_dir, hidden_old_dir_dentry->d_inode);
3138 +
3139 + out_lock:
3140 + /* double_unlock will dput the new/old parent dentries
3141 + * whose refcnts were incremented via get_parent above.
3142 + */
3143 + double_unlock(hidden_old_dir_dentry, hidden_new_dir_dentry);
3144 + dput(hidden_new_dentry);
3145 + dput(hidden_old_dentry);
3146 + out:
3147 + return err;
3148 + }
3149 + else { /* invalid state */
3150 + printk(KERN_CRIT "mini_fo: rename_reg_file: ERROR: invalid state detected [2].\n");
3151 + return -1;
3152 + }
3153 +}
3154 +
3155 +
3156 +STATIC int
3157 +mini_fo_readlink(dentry_t *dentry, char *buf, int bufsiz)
3158 +{
3159 + int err=0;
3160 + dentry_t *hidden_dentry = NULL;
3161 +
3162 + if(dtohd2(dentry) && dtohd2(dentry)->d_inode) {
3163 + hidden_dentry = dtohd2(dentry);
3164 + } else if(dtohd(dentry) && dtohd(dentry)->d_inode) {
3165 + hidden_dentry = dtohd(dentry);
3166 + } else {
3167 + goto out;
3168 + }
3169 +
3170 + if (!hidden_dentry->d_inode->i_op ||
3171 + !hidden_dentry->d_inode->i_op->readlink) {
3172 + err = -EINVAL; goto out;
3173 + }
3174 +
3175 + err = hidden_dentry->d_inode->i_op->readlink(hidden_dentry,
3176 + buf,
3177 + bufsiz);
3178 + if (err > 0)
3179 + fist_copy_attr_atime(dentry->d_inode, hidden_dentry->d_inode);
3180 +
3181 + out:
3182 + return err;
3183 +}
3184 +
3185 +
3186 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,13)
3187 +static int mini_fo_follow_link(dentry_t *dentry, struct nameidata *nd)
3188 +#else
3189 +static void* mini_fo_follow_link(dentry_t *dentry, struct nameidata *nd)
3190 +#endif
3191 +{
3192 + char *buf;
3193 + int len = PAGE_SIZE, err;
3194 + mm_segment_t old_fs;
3195 +
3196 + /* in 2.6 this is freed by mini_fo_put_link called by __do_follow_link */
3197 + buf = kmalloc(len, GFP_KERNEL);
3198 + if (!buf) {
3199 + err = -ENOMEM;
3200 + goto out;
3201 + }
3202 +
3203 + /* read the symlink, and then we will follow it */
3204 + old_fs = get_fs();
3205 + set_fs(KERNEL_DS);
3206 + err = dentry->d_inode->i_op->readlink(dentry, buf, len);
3207 + set_fs(old_fs);
3208 + if (err < 0) {
3209 + kfree(buf);
3210 + buf = NULL;
3211 + goto out;
3212 + }
3213 + buf[err] = 0;
3214 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
3215 + nd_set_link(nd, buf);
3216 + err = 0;
3217 +#else
3218 + err = vfs_follow_link(nd, buf);
3219 +#endif
3220 +
3221 + out:
3222 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
3223 + kfree(buf);
3224 +#endif
3225 +
3226 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,13)
3227 + return err;
3228 +#else
3229 + return ERR_PTR(err);
3230 +#endif
3231 +}
3232 +
3233 +STATIC
3234 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
3235 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,13)
3236 +void mini_fo_put_link(struct dentry *dentry, struct nameidata *nd)
3237 +#else
3238 +void mini_fo_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
3239 +#endif
3240 +{
3241 + char *link;
3242 + link = nd_get_link(nd);
3243 + kfree(link);
3244 +}
3245 +#endif
3246 +
3247 +STATIC int
3248 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
3249 +mini_fo_permission(inode_t *inode, int mask, struct nameidata *nd)
3250 +#else
3251 +mini_fo_permission(inode_t *inode, int mask)
3252 +#endif
3253 +{
3254 + inode_t *hidden_inode;
3255 + int mode;
3256 + int err;
3257 +
3258 + if(itohi2(inode)) {
3259 + hidden_inode = itohi2(inode);
3260 + } else {
3261 + hidden_inode = itohi(inode);
3262 + }
3263 + mode = inode->i_mode;
3264 +
3265 + /* not really needed, as permission handles everything:
3266 + * err = vfs_permission(inode, mask);
3267 + * if (err)
3268 + * goto out;
3269 + */
3270 +
3271 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
3272 + err = permission(hidden_inode, mask, nd);
3273 +#else
3274 + err = permission(hidden_inode, mask);
3275 +#endif
3276 +
3277 + /* out: */
3278 + return err;
3279 +}
3280 +
3281 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
3282 +STATIC int
3283 +mini_fo_inode_revalidate(dentry_t *dentry)
3284 +{
3285 + int err = 0;
3286 + dentry_t *hidden_dentry;
3287 + inode_t *hidden_inode;
3288 +
3289 + ASSERT(dentry->d_inode);
3290 + ASSERT(itopd(dentry->d_inode));
3291 +
3292 + if(itohi2(dentry->d_inode)) {
3293 + hidden_dentry = dtohd2(dentry);
3294 + hidden_inode = hidden_dentry->d_inode;
3295 + } else if(itohi(dentry->d_inode)) {
3296 + hidden_dentry = dtohd(dentry);
3297 + hidden_inode = hidden_dentry->d_inode;
3298 + } else {
3299 + printk(KERN_CRIT "mini_fo_inode_revalidate: ERROR, invalid state detected.\n");
3300 + err = -ENOENT;
3301 + goto out;
3302 + }
3303 + if (hidden_inode && hidden_inode->i_op && hidden_inode->i_op->revalidate){
3304 + err = hidden_inode->i_op->revalidate(hidden_dentry);
3305 + if (err)
3306 + goto out;
3307 + }
3308 + fist_copy_attr_all(dentry->d_inode, hidden_inode);
3309 + out:
3310 + return err;
3311 +}
3312 +#endif
3313 +
3314 +STATIC int
3315 +mini_fo_setattr(dentry_t *dentry, struct iattr *ia)
3316 +{
3317 + int err = 0;
3318 +
3319 + check_mini_fo_dentry(dentry);
3320 +
3321 + if(!is_mini_fo_existant(dentry)) {
3322 + printk(KERN_CRIT "mini_fo_setattr: ERROR, invalid state detected [1].\n");
3323 + goto out;
3324 + }
3325 +
3326 + if(dtost(dentry) == UNMODIFIED) {
3327 + if(!IS_COPY_FLAG(ia->ia_valid))
3328 + goto out; /* we ignore these changes to base */
3329 +
3330 + if(S_ISDIR(dentry->d_inode->i_mode)) {
3331 + err = dir_unmod_to_mod(dentry);
3332 + } else {
3333 + /* we copy contents if file is not beeing truncated */
3334 + if(S_ISREG(dentry->d_inode->i_mode) &&
3335 + !(ia->ia_size == 0 && (ia->ia_valid & ATTR_SIZE))) {
3336 + err = nondir_unmod_to_mod(dentry, 1);
3337 + } else
3338 + err = nondir_unmod_to_mod(dentry, 0);
3339 + }
3340 + if(err) {
3341 + err = -EINVAL;
3342 + printk(KERN_CRIT "mini_fo_setattr: ERROR changing states.\n");
3343 + goto out;
3344 + }
3345 + }
3346 + if(!exists_in_storage(dentry)) {
3347 + printk(KERN_CRIT "mini_fo_setattr: ERROR, invalid state detected [2].\n");
3348 + err = -EINVAL;
3349 + goto out;
3350 + }
3351 + ASSERT(dentry->d_inode);
3352 + ASSERT(dtohd2(dentry));
3353 + ASSERT(itopd(dentry->d_inode));
3354 + ASSERT(itohi2(dentry->d_inode));
3355 +
3356 + err = notify_change(dtohd2(dentry), ia);
3357 + fist_copy_attr_all(dentry->d_inode, itohi2(dentry->d_inode));
3358 + out:
3359 + return err;
3360 +}
3361 +
3362 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
3363 +STATIC int
3364 +mini_fo_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
3365 +{
3366 + int err = 0;
3367 + dentry_t *hidden_dentry;
3368 +
3369 + ASSERT(dentry->d_inode);
3370 + ASSERT(itopd(dentry->d_inode));
3371 +
3372 + if(itohi2(dentry->d_inode)) {
3373 + hidden_dentry = dtohd2(dentry);
3374 + } else if(itohi(dentry->d_inode)) {
3375 + hidden_dentry = dtohd(dentry);
3376 + } else {
3377 + printk(KERN_CRIT "mini_fo_getattr: ERROR, invalid state detected.\n");
3378 + err = -ENOENT;
3379 + goto out;
3380 + }
3381 + fist_copy_attr_all(dentry->d_inode, hidden_dentry->d_inode);
3382 +
3383 + ASSERT(hidden_dentry);
3384 + ASSERT(hidden_dentry->d_inode);
3385 + ASSERT(hidden_dentry->d_inode->i_op);
3386 +
3387 + generic_fillattr(dentry->d_inode, stat);
3388 + if (!stat->blksize) {
3389 + struct super_block *s = hidden_dentry->d_inode->i_sb;
3390 + unsigned blocks;
3391 + blocks = (stat->size+s->s_blocksize-1) >> s->s_blocksize_bits;
3392 + stat->blocks = (s->s_blocksize / 512) * blocks;
3393 + stat->blksize = s->s_blocksize;
3394 + }
3395 + out:
3396 + return err;
3397 +}
3398 +#endif
3399 +
3400 +#if defined(XATTR) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,20))
3401 +#if 0 /* no xattr_alloc() and xattr_free() */
3402 +/* This is lifted from fs/xattr.c */
3403 +static void *
3404 +xattr_alloc(size_t size, size_t limit)
3405 +{
3406 + void *ptr;
3407 +
3408 + if (size > limit)
3409 + return ERR_PTR(-E2BIG);
3410 +
3411 + if (!size) /* size request, no buffer is needed */
3412 + return NULL;
3413 + else if (size <= PAGE_SIZE)
3414 + ptr = kmalloc((unsigned long) size, GFP_KERNEL);
3415 + else
3416 + ptr = vmalloc((unsigned long) size);
3417 + if (!ptr)
3418 + return ERR_PTR(-ENOMEM);
3419 + return ptr;
3420 +}
3421 +
3422 +static void
3423 +xattr_free(void *ptr, size_t size)
3424 +{
3425 + if (!size) /* size request, no buffer was needed */
3426 + return;
3427 + else if (size <= PAGE_SIZE)
3428 + kfree(ptr);
3429 + else
3430 + vfree(ptr);
3431 +}
3432 +#endif /* no xattr_alloc() and xattr_free() */
3433 +
3434 +/* BKL held by caller.
3435 + * dentry->d_inode->i_sem down
3436 + */
3437 +STATIC int
3438 +mini_fo_getxattr(struct dentry *dentry, const char *name, void *value, size_t size) {
3439 + struct dentry *hidden_dentry = NULL;
3440 + int err = -EOPNOTSUPP;
3441 + /* Define these anyway so we don't need as much ifdef'ed code. */
3442 + char *encoded_name = NULL;
3443 + char *encoded_value = NULL;
3444 +
3445 + check_mini_fo_dentry(dentry);
3446 +
3447 + if(exists_in_storage(dentry))
3448 + hidden_dentry = dtohd2(dentry);
3449 + else
3450 + hidden_dentry = dtohd(dentry);
3451 +
3452 + ASSERT(hidden_dentry);
3453 + ASSERT(hidden_dentry->d_inode);
3454 + ASSERT(hidden_dentry->d_inode->i_op);
3455 +
3456 + if (hidden_dentry->d_inode->i_op->getxattr) {
3457 + encoded_name = (char *)name;
3458 + encoded_value = (char *)value;
3459 +
3460 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
3461 + mutex_lock(&hidden_dentry->d_inode->i_mutex);
3462 +#else
3463 + down(&hidden_dentry->d_inode->i_sem);
3464 +#endif
3465 + /* lock_kernel() already done by caller. */
3466 + err = hidden_dentry->d_inode->i_op->getxattr(hidden_dentry, encoded_name, encoded_value, size);
3467 + /* unlock_kernel() will be done by caller. */
3468 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
3469 + mutex_lock(&hidden_dentry->d_inode->i_mutex);
3470 +#else
3471 + up(&hidden_dentry->d_inode->i_sem);
3472 +#endif
3473 + }
3474 + return err;
3475 +}
3476 +
3477 +/* BKL held by caller.
3478 + * dentry->d_inode->i_sem down
3479 + */
3480 +STATIC int
3481 +#if ((LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,21) \
3482 + && LINUX_VERSION_CODE <= KERNEL_VERSION(2,4,23)) \
3483 + || LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
3484 +mini_fo_setxattr(struct dentry *dentry, const char *name,
3485 + const void *value, size_t size, int flags)
3486 +#else
3487 +mini_fo_setxattr(struct dentry *dentry, const char *name,
3488 + void *value, size_t size, int flags)
3489 +#endif
3490 +
3491 +{
3492 + struct dentry *hidden_dentry = NULL;
3493 + int err = -EOPNOTSUPP;
3494 +
3495 + /* Define these anyway, so we don't have as much ifdef'ed code. */
3496 + char *encoded_value = NULL;
3497 + char *encoded_name = NULL;
3498 +
3499 + check_mini_fo_dentry(dentry);
3500 +
3501 + if(exists_in_storage(dentry))
3502 + hidden_dentry = dtohd2(dentry);
3503 + else
3504 + hidden_dentry = dtohd(dentry);
3505 +
3506 + ASSERT(hidden_dentry);
3507 + ASSERT(hidden_dentry->d_inode);
3508 + ASSERT(hidden_dentry->d_inode->i_op);
3509 +
3510 + if (hidden_dentry->d_inode->i_op->setxattr) {
3511 + encoded_name = (char *)name;
3512 + encoded_value = (char *)value;
3513 +
3514 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
3515 + mutex_lock(&hidden_dentry->d_inode->i_mutex);
3516 +#else
3517 + down(&hidden_dentry->d_inode->i_sem);
3518 +#endif
3519 + /* lock_kernel() already done by caller. */
3520 + err = hidden_dentry->d_inode->i_op->setxattr(hidden_dentry, encoded_name, encoded_value, size, flags);
3521 + /* unlock_kernel() will be done by caller. */
3522 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
3523 + mutex_unlock(&hidden_dentry->d_inode->i_mutex);
3524 +#else
3525 + up(&hidden_dentry->d_inode->i_sem);
3526 +#endif
3527 + }
3528 + return err;
3529 +}
3530 +
3531 +/* BKL held by caller.
3532 + * dentry->d_inode->i_sem down
3533 + */
3534 +STATIC int
3535 +mini_fo_removexattr(struct dentry *dentry, const char *name) {
3536 + struct dentry *hidden_dentry = NULL;
3537 + int err = -EOPNOTSUPP;
3538 + char *encoded_name;
3539 +
3540 + check_mini_fo_dentry(dentry);
3541 +
3542 + if(exists_in_storage(dentry))
3543 + hidden_dentry = dtohd2(dentry);
3544 + else
3545 + hidden_dentry = dtohd(dentry);
3546 +
3547 + ASSERT(hidden_dentry);
3548 + ASSERT(hidden_dentry->d_inode);
3549 + ASSERT(hidden_dentry->d_inode->i_op);
3550 +
3551 + if (hidden_dentry->d_inode->i_op->removexattr) {
3552 + encoded_name = (char *)name;
3553 +
3554 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
3555 + mutex_lock(&hidden_dentry->d_inode->i_mutex);
3556 +#else
3557 + down(&hidden_dentry->d_inode->i_sem);
3558 +#endif
3559 + /* lock_kernel() already done by caller. */
3560 + err = hidden_dentry->d_inode->i_op->removexattr(hidden_dentry, encoded_name);
3561 + /* unlock_kernel() will be done by caller. */
3562 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
3563 + mutex_unlock(&hidden_dentry->d_inode->i_mutex);
3564 +#else
3565 + up(&hidden_dentry->d_inode->i_sem);
3566 +#endif
3567 + }
3568 + return err;
3569 +}
3570 +
3571 +/* BKL held by caller.
3572 + * dentry->d_inode->i_sem down
3573 + */
3574 +STATIC int
3575 +mini_fo_listxattr(struct dentry *dentry, char *list, size_t size) {
3576 + struct dentry *hidden_dentry = NULL;
3577 + int err = -EOPNOTSUPP;
3578 + char *encoded_list = NULL;
3579 +
3580 + check_mini_fo_dentry(dentry);
3581 +
3582 + if(exists_in_storage(dentry))
3583 + hidden_dentry = dtohd2(dentry);
3584 + else
3585 + hidden_dentry = dtohd(dentry);
3586 +
3587 + ASSERT(hidden_dentry);
3588 + ASSERT(hidden_dentry->d_inode);
3589 + ASSERT(hidden_dentry->d_inode->i_op);
3590 +
3591 + if (hidden_dentry->d_inode->i_op->listxattr) {
3592 + encoded_list = list;
3593 +
3594 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
3595 + mutex_lock(&hidden_dentry->d_inode->i_mutex);
3596 +#else
3597 + down(&hidden_dentry->d_inode->i_sem);
3598 +#endif
3599 + /* lock_kernel() already done by caller. */
3600 + err = hidden_dentry->d_inode->i_op->listxattr(hidden_dentry, encoded_list, size);
3601 + /* unlock_kernel() will be done by caller. */
3602 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
3603 + mutex_unlock(&hidden_dentry->d_inode->i_mutex);
3604 +#else
3605 + up(&hidden_dentry->d_inode->i_sem);
3606 +#endif
3607 + }
3608 + return err;
3609 +}
3610 +# endif /* defined(XATTR) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,20)) */
3611 +
3612 +struct inode_operations mini_fo_symlink_iops =
3613 + {
3614 + readlink: mini_fo_readlink,
3615 + follow_link: mini_fo_follow_link,
3616 + /* mk: permission: mini_fo_permission, */
3617 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
3618 + revalidate: mini_fo_inode_revalidate,
3619 +#endif
3620 + setattr: mini_fo_setattr,
3621 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
3622 + getattr: mini_fo_getattr,
3623 + put_link: mini_fo_put_link,
3624 +#endif
3625 +
3626 +#if defined(XATTR) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,20))
3627 + setxattr: mini_fo_setxattr,
3628 + getxattr: mini_fo_getxattr,
3629 + listxattr: mini_fo_listxattr,
3630 + removexattr: mini_fo_removexattr
3631 +# endif /* defined(XATTR) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,20)) */
3632 + };
3633 +
3634 +struct inode_operations mini_fo_dir_iops =
3635 + {
3636 + create: mini_fo_create,
3637 + lookup: mini_fo_lookup,
3638 + link: mini_fo_link,
3639 + unlink: mini_fo_unlink,
3640 + symlink: mini_fo_symlink,
3641 + mkdir: mini_fo_mkdir,
3642 + rmdir: mini_fo_rmdir,
3643 + mknod: mini_fo_mknod,
3644 + rename: mini_fo_rename,
3645 + /* no readlink/follow_link for non-symlinks */
3646 + // off because we have setattr
3647 + // truncate: mini_fo_truncate,
3648 + /* mk:permission: mini_fo_permission, */
3649 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
3650 + revalidate: mini_fo_inode_revalidate,
3651 +#endif
3652 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
3653 + getattr: mini_fo_getattr,
3654 +#endif
3655 + setattr: mini_fo_setattr,
3656 +#if defined(XATTR) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,20))
3657 + setxattr: mini_fo_setxattr,
3658 + getxattr: mini_fo_getxattr,
3659 + listxattr: mini_fo_listxattr,
3660 + removexattr: mini_fo_removexattr
3661 +# endif /* XATTR && LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,20) */
3662 + };
3663 +
3664 +struct inode_operations mini_fo_main_iops =
3665 + {
3666 + /* permission: mini_fo_permission, */
3667 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
3668 + revalidate: mini_fo_inode_revalidate,
3669 +#endif
3670 + setattr: mini_fo_setattr,
3671 +
3672 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
3673 + getattr: mini_fo_getattr,
3674 +#endif
3675 +#if defined(XATTR) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,20))
3676 + setxattr: mini_fo_setxattr,
3677 + getxattr: mini_fo_getxattr,
3678 + listxattr: mini_fo_listxattr,
3679 + removexattr: mini_fo_removexattr
3680 +# endif /* XATTR && LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,20) */
3681 + };
3682 --- /dev/null
3683 +++ b/fs/mini_fo/main.c
3684 @@ -0,0 +1,414 @@
3685 +/*
3686 + * Copyright (c) 1997-2003 Erez Zadok
3687 + * Copyright (c) 2001-2003 Stony Brook University
3688 + *
3689 + * For specific licensing information, see the COPYING file distributed with
3690 + * this package, or get one from ftp://ftp.filesystems.org/pub/fist/COPYING.
3691 + *
3692 + * This Copyright notice must be kept intact and distributed with all
3693 + * fistgen sources INCLUDING sources generated by fistgen.
3694 + */
3695 +/*
3696 + * Copyright (C) 2004, 2005 Markus Klotzbuecher <mk@creamnet.de>
3697 + *
3698 + * This program is free software; you can redistribute it and/or
3699 + * modify it under the terms of the GNU General Public License
3700 + * as published by the Free Software Foundation; either version
3701 + * 2 of the License, or (at your option) any later version.
3702 + */
3703 +
3704 +/*
3705 + * $Id$
3706 + */
3707 +
3708 +#ifdef HAVE_CONFIG_H
3709 +# include <config.h>
3710 +#endif
3711 +
3712 +#include "fist.h"
3713 +#include "mini_fo.h"
3714 +#include <linux/module.h>
3715 +
3716 +/* This definition must only appear after we include <linux/module.h> */
3717 +#ifndef MODULE_LICENSE
3718 +# define MODULE_LICENSE(bison)
3719 +#endif /* not MODULE_LICENSE */
3720 +
3721 +/*
3722 + * This is the mini_fo tri interpose function, which extends the
3723 + * functionality of the regular interpose by interposing a higher
3724 + * level inode on top of two lower level ones: the base filesystem
3725 + * inode and the storage filesystem inode.
3726 + *
3727 + * sb we pass is mini_fo's super_block
3728 + */
3729 +int
3730 +mini_fo_tri_interpose(dentry_t *hidden_dentry,
3731 + dentry_t *hidden_sto_dentry,
3732 + dentry_t *dentry, super_block_t *sb, int flag)
3733 +{
3734 + inode_t *hidden_inode = NULL;
3735 + inode_t *hidden_sto_inode = NULL; /* store corresponding storage inode */
3736 + int err = 0;
3737 + inode_t *inode;
3738 +
3739 + /* Pointer to hidden_sto_inode if exists, else to hidden_inode.
3740 + * This is used to copy the attributes of the correct inode. */
3741 + inode_t *master_inode;
3742 +
3743 + if(hidden_dentry)
3744 + hidden_inode = hidden_dentry->d_inode;
3745 + if(hidden_sto_dentry)
3746 + hidden_sto_inode = hidden_sto_dentry->d_inode;
3747 +
3748 + ASSERT(dentry->d_inode == NULL);
3749 +
3750 + /* mk: One of the inodes associated with the dentrys is likely to
3751 + * be NULL, so carefull:
3752 + */
3753 + ASSERT((hidden_inode != NULL) || (hidden_sto_inode != NULL));
3754 +
3755 + if(hidden_sto_inode)
3756 + master_inode = hidden_sto_inode;
3757 + else
3758 + master_inode = hidden_inode;
3759 +
3760 + /*
3761 + * We allocate our new inode below, by calling iget.
3762 + * iget will call our read_inode which will initialize some
3763 + * of the new inode's fields
3764 + */
3765 +
3766 + /*
3767 + * original: inode = iget(sb, hidden_inode->i_ino);
3768 + */
3769 + inode = iget(sb, iunique(sb, 25));
3770 + if (!inode) {
3771 + err = -EACCES; /* should be impossible??? */
3772 + goto out;
3773 + }
3774 +
3775 + /*
3776 + * interpose the inode if not already interposed
3777 + * this is possible if the inode is being reused
3778 + * XXX: what happens if we get_empty_inode() but there's another already?
3779 + * for now, ASSERT() that this can't happen; fix later.
3780 + */
3781 + if (itohi(inode) != NULL) {
3782 + printk(KERN_CRIT "mini_fo_tri_interpose: itohi(inode) != NULL.\n");
3783 + }
3784 + if (itohi2(inode) != NULL) {
3785 + printk(KERN_CRIT "mini_fo_tri_interpose: itohi2(inode) != NULL.\n");
3786 + }
3787 +
3788 + /* mk: Carefull, igrab can't handle NULL inodes (ok, why should it?), so
3789 + * we need to check here:
3790 + */
3791 + if(hidden_inode)
3792 + itohi(inode) = igrab(hidden_inode);
3793 + else
3794 + itohi(inode) = NULL;
3795 +
3796 + if(hidden_sto_inode)
3797 + itohi2(inode) = igrab(hidden_sto_inode);
3798 + else
3799 + itohi2(inode) = NULL;
3800 +
3801 +
3802 + /* Use different set of inode ops for symlinks & directories*/
3803 + if (S_ISLNK(master_inode->i_mode))
3804 + inode->i_op = &mini_fo_symlink_iops;
3805 + else if (S_ISDIR(master_inode->i_mode))
3806 + inode->i_op = &mini_fo_dir_iops;
3807 +
3808 + /* Use different set of file ops for directories */
3809 + if (S_ISDIR(master_inode->i_mode))
3810 + inode->i_fop = &mini_fo_dir_fops;
3811 +
3812 + /* properly initialize special inodes */
3813 + if (S_ISBLK(master_inode->i_mode) || S_ISCHR(master_inode->i_mode) ||
3814 + S_ISFIFO(master_inode->i_mode) || S_ISSOCK(master_inode->i_mode)) {
3815 + init_special_inode(inode, master_inode->i_mode, master_inode->i_rdev);
3816 + }
3817 +
3818 + /* Fix our inode's address operations to that of the lower inode */
3819 + if (inode->i_mapping->a_ops != master_inode->i_mapping->a_ops) {
3820 + inode->i_mapping->a_ops = master_inode->i_mapping->a_ops;
3821 + }
3822 +
3823 + /* only (our) lookup wants to do a d_add */
3824 + if (flag)
3825 + d_add(dentry, inode);
3826 + else
3827 + d_instantiate(dentry, inode);
3828 +
3829 + ASSERT(dtopd(dentry) != NULL);
3830 +
3831 + /* all well, copy inode attributes */
3832 + fist_copy_attr_all(inode, master_inode);
3833 +
3834 + out:
3835 + return err;
3836 +}
3837 +
3838 +/* parse mount options "base=" and "sto=" */
3839 +dentry_t *
3840 +mini_fo_parse_options(super_block_t *sb, char *options)
3841 +{
3842 + dentry_t *hidden_root = ERR_PTR(-EINVAL);
3843 + dentry_t *hidden_root2 = ERR_PTR(-EINVAL);
3844 + struct nameidata nd, nd2;
3845 + char *name, *tmp, *end;
3846 + int err = 0;
3847 +
3848 + /* We don't want to go off the end of our arguments later on. */
3849 + for (end = options; *end; end++);
3850 +
3851 + while (options < end) {
3852 + tmp = options;
3853 + while (*tmp && *tmp != ',')
3854 + tmp++;
3855 + *tmp = '\0';
3856 + if (!strncmp("base=", options, 5)) {
3857 + name = options + 5;
3858 + printk(KERN_INFO "mini_fo: using base directory: %s\n", name);
3859 +
3860 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
3861 + if (path_init(name, LOOKUP_FOLLOW, &nd))
3862 + err = path_walk(name, &nd);
3863 +#else
3864 + err = path_lookup(name, LOOKUP_FOLLOW, &nd);
3865 +#endif
3866 + if (err) {
3867 + printk(KERN_CRIT "mini_fo: error accessing hidden directory '%s'\n", name);
3868 + hidden_root = ERR_PTR(err);
3869 + goto out;
3870 + }
3871 + hidden_root = nd.dentry;
3872 + stopd(sb)->base_dir_dentry = nd.dentry;
3873 + stopd(sb)->hidden_mnt = nd.mnt;
3874 +
3875 + } else if(!strncmp("sto=", options, 4)) {
3876 + /* parse the storage dir */
3877 + name = options + 4;
3878 + printk(KERN_INFO "mini_fo: using storage directory: %s\n", name);
3879 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
3880 + if(path_init(name, LOOKUP_FOLLOW, &nd2))
3881 + err = path_walk(name, &nd2);
3882 +#else
3883 + err = path_lookup(name, LOOKUP_FOLLOW, &nd2);
3884 +#endif
3885 + if(err) {
3886 + printk(KERN_CRIT "mini_fo: error accessing hidden storage directory '%s'\n", name);
3887 +
3888 + hidden_root2 = ERR_PTR(err);
3889 + goto out;
3890 + }
3891 + hidden_root2 = nd2.dentry;
3892 + stopd(sb)->storage_dir_dentry = nd2.dentry;
3893 + stopd(sb)->hidden_mnt2 = nd2.mnt;
3894 + stohs2(sb) = hidden_root2->d_sb;
3895 +
3896 + /* validate storage dir, this is done in
3897 + * mini_fo_read_super for the base directory.
3898 + */
3899 + if (IS_ERR(hidden_root2)) {
3900 + printk(KERN_WARNING "mini_fo_parse_options: storage dentry lookup failed (err = %ld)\n", PTR_ERR(hidden_root2));
3901 + goto out;
3902 + }
3903 + if (!hidden_root2->d_inode) {
3904 + printk(KERN_WARNING "mini_fo_parse_options: no storage dir to interpose on.\n");
3905 + goto out;
3906 + }
3907 + stohs2(sb) = hidden_root2->d_sb;
3908 + } else {
3909 + printk(KERN_WARNING "mini_fo: unrecognized option '%s'\n", options);
3910 + hidden_root = ERR_PTR(-EINVAL);
3911 + goto out;
3912 + }
3913 + options = tmp + 1;
3914 + }
3915 +
3916 + out:
3917 + if(IS_ERR(hidden_root2))
3918 + return hidden_root2;
3919 + return hidden_root;
3920 +}
3921 +
3922 +
3923 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
3924 +static int
3925 +#else
3926 +super_block_t *
3927 +#endif
3928 +mini_fo_read_super(super_block_t *sb, void *raw_data, int silent)
3929 +{
3930 + dentry_t *hidden_root;
3931 + int err = 0;
3932 +
3933 + if (!raw_data) {
3934 + printk(KERN_WARNING "mini_fo_read_super: missing argument\n");
3935 + err = -EINVAL;
3936 + goto out;
3937 + }
3938 + /*
3939 + * Allocate superblock private data
3940 + */
3941 + __stopd(sb) = kmalloc(sizeof(struct mini_fo_sb_info), GFP_KERNEL);
3942 + if (!stopd(sb)) {
3943 + printk(KERN_WARNING "%s: out of memory\n", __FUNCTION__);
3944 + err = -ENOMEM;
3945 + goto out;
3946 + }
3947 + stohs(sb) = NULL;
3948 +
3949 + hidden_root = mini_fo_parse_options(sb, raw_data);
3950 + if (IS_ERR(hidden_root)) {
3951 + printk(KERN_WARNING "mini_fo_read_super: lookup_dentry failed (err = %ld)\n", PTR_ERR(hidden_root));
3952 + err = PTR_ERR(hidden_root);
3953 + goto out_free;
3954 + }
3955 + if (!hidden_root->d_inode) {
3956 + printk(KERN_WARNING "mini_fo_read_super: no directory to interpose on\n");
3957 + goto out_free;
3958 + }
3959 + stohs(sb) = hidden_root->d_sb;
3960 +
3961 + /*
3962 + * Linux 2.4.2-ac3 and beyond has code in
3963 + * mm/filemap.c:generic_file_write() that requires sb->s_maxbytes
3964 + * to be populated. If not set, all write()s under that sb will
3965 + * return 0.
3966 + *
3967 + * Linux 2.4.4+ automatically sets s_maxbytes to MAX_NON_LFS;
3968 + * the filesystem should override it only if it supports LFS.
3969 + */
3970 + /* non-SCA code is good to go with LFS */
3971 + sb->s_maxbytes = hidden_root->d_sb->s_maxbytes;
3972 +
3973 + sb->s_op = &mini_fo_sops;
3974 + /*
3975 + * we can't use d_alloc_root if we want to use
3976 + * our own interpose function unchanged,
3977 + * so we simply replicate *most* of the code in d_alloc_root here
3978 + */
3979 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
3980 + sb->s_root = d_alloc(NULL, &(const struct qstr) { "/", 1, 0 });
3981 +#else
3982 + sb->s_root = d_alloc(NULL, &(const struct qstr){hash: 0, name: "/", len : 1});
3983 +#endif
3984 + if (IS_ERR(sb->s_root)) {
3985 + printk(KERN_WARNING "mini_fo_read_super: d_alloc failed\n");
3986 + err = -ENOMEM;
3987 + goto out_dput;
3988 + }
3989 +
3990 + sb->s_root->d_op = &mini_fo_dops;
3991 + sb->s_root->d_sb = sb;
3992 + sb->s_root->d_parent = sb->s_root;
3993 +
3994 + /* link the upper and lower dentries */
3995 + __dtopd(sb->s_root) = (struct mini_fo_dentry_info *)
3996 + kmalloc(sizeof(struct mini_fo_dentry_info), GFP_KERNEL);
3997 + if (!dtopd(sb->s_root)) {
3998 + err = -ENOMEM;
3999 + goto out_dput2;
4000 + }
4001 + dtopd(sb->s_root)->state = MODIFIED;
4002 + dtohd(sb->s_root) = hidden_root;
4003 +
4004 + /* fanout relevant, interpose on storage root dentry too */
4005 + dtohd2(sb->s_root) = stopd(sb)->storage_dir_dentry;
4006 +
4007 + /* ...and call tri-interpose to interpose root dir inodes
4008 + * if (mini_fo_interpose(hidden_root, sb->s_root, sb, 0))
4009 + */
4010 + if(mini_fo_tri_interpose(hidden_root, dtohd2(sb->s_root), sb->s_root, sb, 0))
4011 + goto out_dput2;
4012 +
4013 + /* initalize the wol list */
4014 + itopd(sb->s_root->d_inode)->deleted_list_size = -1;
4015 + itopd(sb->s_root->d_inode)->renamed_list_size = -1;
4016 + meta_build_lists(sb->s_root);
4017 +
4018 + goto out;
4019 +
4020 + out_dput2:
4021 + dput(sb->s_root);
4022 + out_dput:
4023 + dput(hidden_root);
4024 + dput(dtohd2(sb->s_root)); /* release the hidden_sto_dentry too */
4025 + out_free:
4026 + kfree(stopd(sb));
4027 + __stopd(sb) = NULL;
4028 + out:
4029 +
4030 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
4031 + return err;
4032 +#else
4033 + if (err) {
4034 + return ERR_PTR(err);
4035 + } else {
4036 + return sb;
4037 + }
4038 +#endif
4039 +}
4040 +
4041 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
4042 +static struct super_block *mini_fo_get_sb(struct file_system_type *fs_type,
4043 + int flags, const char *dev_name,
4044 + void *raw_data)
4045 +{
4046 + return get_sb_nodev(fs_type, flags, raw_data, mini_fo_read_super);
4047 +}
4048 +
4049 +void mini_fo_kill_block_super(struct super_block *sb)
4050 +{
4051 + generic_shutdown_super(sb);
4052 + /*
4053 + * XXX: BUG: Halcrow: Things get unstable sometime after this point:
4054 + * lib/rwsem-spinlock.c:127: spin_is_locked on uninitialized
4055 + * fs/fs-writeback.c:402: spin_lock(fs/super.c:a0381828) already
4056 + * locked by fs/fs-writeback.c/402
4057 + *
4058 + * Apparently, someone's not releasing a lock on sb_lock...
4059 + */
4060 +}
4061 +
4062 +static struct file_system_type mini_fo_fs_type = {
4063 + .owner = THIS_MODULE,
4064 + .name = "mini_fo",
4065 + .get_sb = mini_fo_get_sb,
4066 + .kill_sb = mini_fo_kill_block_super,
4067 + .fs_flags = 0,
4068 +};
4069 +
4070 +
4071 +#else
4072 +static DECLARE_FSTYPE(mini_fo_fs_type, "mini_fo", mini_fo_read_super, 0);
4073 +#endif
4074 +
4075 +static int __init init_mini_fo_fs(void)
4076 +{
4077 + printk("Registering mini_fo version $Id$\n");
4078 + return register_filesystem(&mini_fo_fs_type);
4079 +}
4080 +static void __exit exit_mini_fo_fs(void)
4081 +{
4082 + printk("Unregistering mini_fo version $Id$\n");
4083 + unregister_filesystem(&mini_fo_fs_type);
4084 +}
4085 +
4086 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
4087 +EXPORT_NO_SYMBOLS;
4088 +#endif
4089 +
4090 +MODULE_AUTHOR("Erez Zadok <ezk@cs.sunysb.edu>");
4091 +MODULE_DESCRIPTION("FiST-generated mini_fo filesystem");
4092 +MODULE_LICENSE("GPL");
4093 +
4094 +/* MODULE_PARM(fist_debug_var, "i"); */
4095 +/* MODULE_PARM_DESC(fist_debug_var, "Debug level"); */
4096 +
4097 +module_init(init_mini_fo_fs)
4098 +module_exit(exit_mini_fo_fs)
4099 --- /dev/null
4100 +++ b/fs/mini_fo/Makefile
4101 @@ -0,0 +1,22 @@
4102 +#
4103 +# Makefile for mini_fo 2.4 and 2.6 Linux kernels
4104 +#
4105 +# Copyright (C) 2004, 2005 Markus Klotzbuecher <mk@creamnet.de>
4106 +#
4107 +# This program is free software; you can redistribute it and/or
4108 +# modify it under the terms of the GNU General Public License
4109 +# as published by the Free Software Foundation; either version
4110 +# 2 of the License, or (at your option) any later version.
4111 +#
4112 +
4113 +obj-$(CONFIG_MINI_FO) := mini_fo.o
4114 +mini_fo-objs := meta.o dentry.o file.o inode.o main.o super.o state.o aux.o
4115 +
4116 +O_TARGET := $(obj-$(CONFIG_MINI_FO))
4117 +obj-y := $(mini_fo-objs)
4118 +
4119 +-include $(TOPDIR)/Rules.make
4120 +
4121 +# dependencies
4122 +${mini_fo-objs}: mini_fo.h fist.h
4123 +
4124 --- /dev/null
4125 +++ b/fs/mini_fo/meta.c
4126 @@ -0,0 +1,1000 @@
4127 +/*
4128 + * Copyright (C) 2004, 2005 Markus Klotzbuecher <mk@creamnet.de>
4129 + *
4130 + * This program is free software; you can redistribute it and/or
4131 + * modify it under the terms of the GNU General Public License
4132 + * as published by the Free Software Foundation; either version
4133 + * 2 of the License, or (at your option) any later version.
4134 + */
4135 +
4136 +#ifdef HAVE_CONFIG_H
4137 +# include <config.h>
4138 +#endif /* HAVE_CONFIG_H */
4139 +#include "fist.h"
4140 +#include "mini_fo.h"
4141 +
4142 +int meta_build_lists(dentry_t *dentry)
4143 +{
4144 + struct mini_fo_inode_info *inode_info;
4145 +
4146 + dentry_t *meta_dentry = 0;
4147 + file_t *meta_file = 0;
4148 + mm_segment_t old_fs;
4149 + void *buf;
4150 +
4151 + int bytes, len;
4152 + struct vfsmount *meta_mnt;
4153 + char *entry;
4154 +
4155 + inode_info = itopd(dentry->d_inode);
4156 + if(!(inode_info->deleted_list_size == -1 &&
4157 + inode_info->renamed_list_size == -1)) {
4158 + printk(KERN_CRIT "mini_fo: meta_build_lists: \
4159 + Error, list(s) not virgin.\n");
4160 + return -1;
4161 + }
4162 +
4163 + /* init our meta lists */
4164 + INIT_LIST_HEAD(&inode_info->deleted_list);
4165 + inode_info->deleted_list_size = 0;
4166 +
4167 + INIT_LIST_HEAD(&inode_info->renamed_list);
4168 + inode_info->renamed_list_size = 0;
4169 +
4170 + /* might there be a META-file? */
4171 + if(dtohd2(dentry) && dtohd2(dentry)->d_inode) {
4172 + meta_dentry = lookup_one_len(META_FILENAME,
4173 + dtohd2(dentry),
4174 + strlen(META_FILENAME));
4175 + if(!meta_dentry->d_inode) {
4176 + dput(meta_dentry);
4177 + goto out_ok;
4178 + }
4179 + /* $%& err, is this correct? */
4180 + meta_mnt = stopd(dentry->d_inode->i_sb)->hidden_mnt2;
4181 + mntget(meta_mnt);
4182 +
4183 +
4184 + /* open META-file for reading */
4185 + meta_file = dentry_open(meta_dentry, meta_mnt, 0x0);
4186 + if(!meta_file || IS_ERR(meta_file)) {
4187 + printk(KERN_CRIT "mini_fo: meta_build_lists: \
4188 + ERROR opening META file.\n");
4189 + goto out_err;
4190 + }
4191 +
4192 + /* check if fs supports reading */
4193 + if(!meta_file->f_op->read) {
4194 + printk(KERN_CRIT "mini_fo: meta_build_lists: \
4195 + ERROR, fs does not support reading.\n");
4196 + goto out_err_close;
4197 + }
4198 +
4199 + /* allocate a page for transfering the data */
4200 + buf = (void *) __get_free_page(GFP_KERNEL);
4201 + if(!buf) {
4202 + printk(KERN_CRIT "mini_fo: meta_build_lists: \
4203 + ERROR, out of mem.\n");
4204 + goto out_err_close;
4205 + }
4206 + meta_file->f_pos = 0;
4207 + old_fs = get_fs();
4208 + set_fs(KERNEL_DS);
4209 + do {
4210 + char *c;
4211 + bytes = meta_file->f_op->read(meta_file, buf, PAGE_SIZE, &meta_file->f_pos);
4212 + if(bytes == PAGE_SIZE) {
4213 + /* trim a cut off filename and adjust f_pos to get it next time */
4214 + for(c = (char*) buf+PAGE_SIZE;
4215 + *c != '\n';
4216 + c--, bytes--, meta_file->f_pos--);
4217 + }
4218 + entry = (char *) buf;
4219 + while(entry < (char *) buf+bytes) {
4220 +
4221 + char *old_path;
4222 + char *dir_name;
4223 + int old_len, new_len;
4224 +
4225 + /* len without '\n'*/
4226 + len = (int) (strchr(entry, '\n') - entry);
4227 + switch (*entry) {
4228 + case 'D':
4229 + /* format: "D filename" */
4230 + meta_list_add_d_entry(dentry,
4231 + entry+2,
4232 + len-2);
4233 + break;
4234 + case 'R':
4235 + /* format: "R path/xy/dir newDir" */
4236 + old_path = entry+2;
4237 + dir_name = strchr(old_path, ' ') + 1;
4238 + old_len = dir_name - old_path - 1;
4239 + new_len = ((int) entry) + len - ((int ) dir_name);
4240 + meta_list_add_r_entry(dentry,
4241 + old_path,
4242 + old_len,
4243 + dir_name,
4244 + new_len);
4245 + break;
4246 + default:
4247 + /* unknown entry type detected */
4248 + break;
4249 + }
4250 + entry += len+1;
4251 + }
4252 +
4253 + } while(meta_file->f_pos < meta_dentry->d_inode->i_size);
4254 +
4255 + free_page((unsigned long) buf);
4256 + set_fs(old_fs);
4257 + fput(meta_file);
4258 + }
4259 + goto out_ok;
4260 +
4261 + out_err_close:
4262 + fput(meta_file);
4263 + out_err:
4264 + mntput(meta_mnt);
4265 + dput(meta_dentry);
4266 + return -1;
4267 + out_ok:
4268 + return 1; /* check this!!! inode_info->wol_size; */
4269 +}
4270 +
4271 +/* cleanups up all lists and free's the mem by dentry */
4272 +int meta_put_lists(dentry_t *dentry)
4273 +{
4274 + if(!dentry || !dentry->d_inode) {
4275 + printk("mini_fo: meta_put_lists: invalid dentry passed.\n");
4276 + return -1;
4277 + }
4278 + return __meta_put_lists(dentry->d_inode);
4279 +}
4280 +
4281 +/* cleanups up all lists and free's the mem by inode */
4282 +int __meta_put_lists(inode_t *inode)
4283 +{
4284 + int err = 0;
4285 + if(!inode || !itopd(inode)) {
4286 + printk("mini_fo: __meta_put_lists: invalid inode passed.\n");
4287 + return -1;
4288 + }
4289 + err = __meta_put_d_list(inode);
4290 + err |= __meta_put_r_list(inode);
4291 + return err;
4292 +}
4293 +
4294 +int meta_sync_lists(dentry_t *dentry)
4295 +{
4296 + int err = 0;
4297 + if(!dentry || !dentry->d_inode) {
4298 + printk("mini_fo: meta_sync_lists: \
4299 + invalid dentry passed.\n");
4300 + return -1;
4301 + }
4302 + err = meta_sync_d_list(dentry, 0);
4303 + err |= meta_sync_r_list(dentry, 1);
4304 + return err;
4305 +}
4306 +
4307 +
4308 +/* remove all D entries from the renamed list and free the mem */
4309 +int __meta_put_d_list(inode_t *inode)
4310 +{
4311 + struct list_head *tmp;
4312 + struct deleted_entry *del_entry;
4313 + struct mini_fo_inode_info *inode_info;
4314 +
4315 + if(!inode || !itopd(inode)) {
4316 + printk(KERN_CRIT "mini_fo: __meta_put_d_list: \
4317 + invalid inode passed.\n");
4318 + return -1;
4319 + }
4320 + inode_info = itopd(inode);
4321 +
4322 + /* nuke the DELETED-list */
4323 + if(inode_info->deleted_list_size <= 0)
4324 + return 0;
4325 +
4326 + while(!list_empty(&inode_info->deleted_list)) {
4327 + tmp = inode_info->deleted_list.next;
4328 + list_del(tmp);
4329 + del_entry = list_entry(tmp, struct deleted_entry, list);
4330 + kfree(del_entry->name);
4331 + kfree(del_entry);
4332 + }
4333 + inode_info->deleted_list_size = 0;
4334 +
4335 + return 0;
4336 +}
4337 +
4338 +/* remove all R entries from the renamed list and free the mem */
4339 +int __meta_put_r_list(inode_t *inode)
4340 +{
4341 + struct list_head *tmp;
4342 + struct renamed_entry *ren_entry;
4343 + struct mini_fo_inode_info *inode_info;
4344 +
4345 + if(!inode || !itopd(inode)) {
4346 + printk(KERN_CRIT "mini_fo: meta_put_r_list: invalid inode.\n");
4347 + return -1;
4348 + }
4349 + inode_info = itopd(inode);
4350 +
4351 + /* nuke the RENAMED-list */
4352 + if(inode_info->renamed_list_size <= 0)
4353 + return 0;
4354 +
4355 + while(!list_empty(&inode_info->renamed_list)) {
4356 + tmp = inode_info->renamed_list.next;
4357 + list_del(tmp);
4358 + ren_entry = list_entry(tmp, struct renamed_entry, list);
4359 + kfree(ren_entry->new_name);
4360 + kfree(ren_entry->old_name);
4361 + kfree(ren_entry);
4362 + }
4363 + inode_info->renamed_list_size = 0;
4364 +
4365 + return 0;
4366 +}
4367 +
4368 +int meta_add_d_entry(dentry_t *dentry, const char *name, int len)
4369 +{
4370 + int err = 0;
4371 + err = meta_list_add_d_entry(dentry, name, len);
4372 + err |= meta_write_d_entry(dentry,name,len);
4373 + return err;
4374 +}
4375 +
4376 +/* add a D entry to the deleted list */
4377 +int meta_list_add_d_entry(dentry_t *dentry, const char *name, int len)
4378 +{
4379 + struct deleted_entry *del_entry;
4380 + struct mini_fo_inode_info *inode_info;
4381 +
4382 + if(!dentry || !dentry->d_inode) {
4383 + printk(KERN_CRIT "mini_fo: meta_list_add_d_entry: \
4384 + invalid dentry passed.\n");
4385 + return -1;
4386 + }
4387 + inode_info = itopd(dentry->d_inode);
4388 +
4389 + if(inode_info->deleted_list_size < 0)
4390 + return -1;
4391 +
4392 + del_entry = (struct deleted_entry *)
4393 + kmalloc(sizeof(struct deleted_entry), GFP_KERNEL);
4394 + del_entry->name = (char*) kmalloc(len, GFP_KERNEL);
4395 + if(!del_entry || !del_entry->name) {
4396 + printk(KERN_CRIT "mini_fo: meta_list_add_d_entry: \
4397 + out of mem.\n");
4398 + kfree(del_entry->name);
4399 + kfree(del_entry);
4400 + return -ENOMEM;
4401 + }
4402 +
4403 + strncpy(del_entry->name, name, len);
4404 + del_entry->len = len;
4405 +
4406 + list_add(&del_entry->list, &inode_info->deleted_list);
4407 + inode_info->deleted_list_size++;
4408 + return 0;
4409 +}
4410 +
4411 +int meta_add_r_entry(dentry_t *dentry,
4412 + const char *old_name, int old_len,
4413 + const char *new_name, int new_len)
4414 +{
4415 + int err = 0;
4416 + err = meta_list_add_r_entry(dentry,
4417 + old_name, old_len,
4418 + new_name, new_len);
4419 + err |= meta_write_r_entry(dentry,
4420 + old_name, old_len,
4421 + new_name, new_len);
4422 + return err;
4423 +}
4424 +
4425 +/* add a R entry to the renamed list */
4426 +int meta_list_add_r_entry(dentry_t *dentry,
4427 + const char *old_name, int old_len,
4428 + const char *new_name, int new_len)
4429 +{
4430 + struct renamed_entry *ren_entry;
4431 + struct mini_fo_inode_info *inode_info;
4432 +
4433 + if(!dentry || !dentry->d_inode) {
4434 + printk(KERN_CRIT "mini_fo: meta_list_add_r_entry: \
4435 + invalid dentry passed.\n");
4436 + return -1;
4437 + }
4438 + inode_info = itopd(dentry->d_inode);
4439 +
4440 + if(inode_info->renamed_list_size < 0)
4441 + return -1;
4442 +
4443 + ren_entry = (struct renamed_entry *)
4444 + kmalloc(sizeof(struct renamed_entry), GFP_KERNEL);
4445 + ren_entry->old_name = (char*) kmalloc(old_len, GFP_KERNEL);
4446 + ren_entry->new_name = (char*) kmalloc(new_len, GFP_KERNEL);
4447 +
4448 + if(!ren_entry || !ren_entry->old_name || !ren_entry->new_name) {
4449 + printk(KERN_CRIT "mini_fo: meta_list_add_r_entry: \
4450 + out of mem.\n");
4451 + kfree(ren_entry->new_name);
4452 + kfree(ren_entry->old_name);
4453 + kfree(ren_entry);
4454 + return -ENOMEM;
4455 + }
4456 +
4457 + strncpy(ren_entry->old_name, old_name, old_len);
4458 + ren_entry->old_len = old_len;
4459 + strncpy(ren_entry->new_name, new_name, new_len);
4460 + ren_entry->new_len = new_len;
4461 +
4462 + list_add(&ren_entry->list, &inode_info->renamed_list);
4463 + inode_info->renamed_list_size++;
4464 + return 0;
4465 +}
4466 +
4467 +
4468 +int meta_remove_r_entry(dentry_t *dentry, const char *name, int len)
4469 +{
4470 + int err = 0;
4471 + if(!dentry || !dentry->d_inode) {
4472 + printk(KERN_CRIT
4473 + "mini_fo: meta_remove_r_entry: \
4474 + invalid dentry passed.\n");
4475 + return -1;
4476 + }
4477 +
4478 + err = meta_list_remove_r_entry(dentry, name, len);
4479 + err |= meta_sync_lists(dentry);
4480 + return err;
4481 +}
4482 +
4483 +int meta_list_remove_r_entry(dentry_t *dentry, const char *name, int len)
4484 +{
4485 + if(!dentry || !dentry->d_inode) {
4486 + printk(KERN_CRIT
4487 + "mini_fo: meta_list_remove_r_entry: \
4488 + invalid dentry passed.\n");
4489 + return -1;
4490 + }
4491 + return __meta_list_remove_r_entry(dentry->d_inode, name, len);
4492 +}
4493 +
4494 +int __meta_list_remove_r_entry(inode_t *inode, const char *name, int len)
4495 +{
4496 + struct list_head *tmp;
4497 + struct renamed_entry *ren_entry;
4498 + struct mini_fo_inode_info *inode_info;
4499 +
4500 + if(!inode || !itopd(inode))
4501 + printk(KERN_CRIT
4502 + "mini_fo: __meta_list_remove_r_entry: \
4503 + invalid inode passed.\n");
4504 + inode_info = itopd(inode);
4505 +
4506 + if(inode_info->renamed_list_size < 0)
4507 + return -1;
4508 + if(inode_info->renamed_list_size == 0)
4509 + return 1;
4510 +
4511 + list_for_each(tmp, &inode_info->renamed_list) {
4512 + ren_entry = list_entry(tmp, struct renamed_entry, list);
4513 + if(ren_entry->new_len != len)
4514 + continue;
4515 +
4516 + if(!strncmp(ren_entry->new_name, name, len)) {
4517 + list_del(tmp);
4518 + kfree(ren_entry->new_name);
4519 + kfree(ren_entry->old_name);
4520 + kfree(ren_entry);
4521 + inode_info->renamed_list_size--;
4522 + return 0;
4523 + }
4524 + }
4525 + return 1;
4526 +}
4527 +
4528 +
4529 +/* append a single D entry to the meta file */
4530 +int meta_write_d_entry(dentry_t *dentry, const char *name, int len)
4531 +{
4532 + dentry_t *meta_dentry = 0;
4533 + file_t *meta_file = 0;
4534 + mm_segment_t old_fs;
4535 +
4536 + int bytes, err;
4537 + struct vfsmount *meta_mnt = 0;
4538 + char *buf;
4539 +
4540 + err = 0;
4541 +
4542 + if(itopd(dentry->d_inode)->deleted_list_size < 0) {
4543 + err = -1;
4544 + goto out;
4545 + }
4546 +
4547 + if(dtopd(dentry)->state == UNMODIFIED) {
4548 + err = build_sto_structure(dentry->d_parent, dentry);
4549 + if(err) {
4550 + printk(KERN_CRIT "mini_fo: meta_write_d_entry: \
4551 + build_sto_structure failed.\n");
4552 + goto out;
4553 + }
4554 + }
4555 + meta_dentry = lookup_one_len(META_FILENAME,
4556 + dtohd2(dentry), strlen (META_FILENAME));
4557 +
4558 + /* We need to create a META-file */
4559 + if(!meta_dentry->d_inode) {
4560 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
4561 + vfs_create(dtohd2(dentry)->d_inode,
4562 + meta_dentry,
4563 + S_IRUSR | S_IWUSR,
4564 + NULL);
4565 +#else
4566 + vfs_create(dtohd2(dentry)->d_inode,
4567 + meta_dentry,
4568 + S_IRUSR | S_IWUSR);
4569 +#endif
4570 + }
4571 + /* open META-file for writing */
4572 + meta_file = dentry_open(meta_dentry, meta_mnt, 0x1);
4573 + if(!meta_file || IS_ERR(meta_file)) {
4574 + printk(KERN_CRIT "mini_fo: meta_write_d_entry: \
4575 + ERROR opening meta file.\n");
4576 + mntput(meta_mnt); /* $%& is this necessary? */
4577 + dput(meta_dentry);
4578 + err = -1;
4579 + goto out;
4580 + }
4581 +
4582 + /* check if fs supports writing */
4583 + if(!meta_file->f_op->write) {
4584 + printk(KERN_CRIT "mini_fo: meta_write_d_entry: \
4585 + ERROR, fs does not support writing.\n");
4586 + goto out_err_close;
4587 + }
4588 +
4589 + meta_file->f_pos = meta_dentry->d_inode->i_size; /* append */
4590 + old_fs = get_fs();
4591 + set_fs(KERNEL_DS);
4592 +
4593 + /* size: len for name, 1 for \n and 2 for "D " */
4594 + buf = (char *) kmalloc(len+3, GFP_KERNEL);
4595 + if (!buf) {
4596 + printk(KERN_CRIT "mini_fo: meta_write_d_entry: \
4597 + out of mem.\n");
4598 + return -ENOMEM;
4599 + }
4600 +
4601 + buf[0] = 'D';
4602 + buf[1] = ' ';
4603 + strncpy(buf+2, name, len);
4604 + buf[len+2] = '\n';
4605 + bytes = meta_file->f_op->write(meta_file, buf, len+3,
4606 + &meta_file->f_pos);
4607 + if(bytes != len+3) {
4608 + printk(KERN_CRIT "mini_fo: meta_write_d_entry: \
4609 + ERROR writing.\n");
4610 + err = -1;
4611 + }
4612 + kfree(buf);
4613 + set_fs(old_fs);
4614 +
4615 + out_err_close:
4616 + fput(meta_file);
4617 + out:
4618 + return err;
4619 +}
4620 +
4621 +/* append a single R entry to the meta file */
4622 +int meta_write_r_entry(dentry_t *dentry,
4623 + const char *old_name, int old_len,
4624 + const char *new_name, int new_len)
4625 +{
4626 + dentry_t *meta_dentry = 0;
4627 + file_t *meta_file = 0;
4628 + mm_segment_t old_fs;
4629 +
4630 + int bytes, err, buf_len;
4631 + struct vfsmount *meta_mnt = 0;
4632 + char *buf;
4633 +
4634 +
4635 + err = 0;
4636 +
4637 + if(itopd(dentry->d_inode)->renamed_list_size < 0) {
4638 + err = -1;
4639 + goto out;
4640 + }
4641 +
4642 + /* build the storage structure? */
4643 + if(dtopd(dentry)->state == UNMODIFIED) {
4644 + err = build_sto_structure(dentry->d_parent, dentry);
4645 + if(err) {
4646 + printk(KERN_CRIT "mini_fo: meta_write_r_entry: \
4647 + build_sto_structure failed.\n");
4648 + goto out;
4649 + }
4650 + }
4651 + meta_dentry = lookup_one_len(META_FILENAME,
4652 + dtohd2(dentry),
4653 + strlen (META_FILENAME));
4654 + if(!meta_dentry->d_inode) {
4655 + /* We need to create a META-file */
4656 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
4657 + vfs_create(dtohd2(dentry)->d_inode,
4658 + meta_dentry, S_IRUSR | S_IWUSR, NULL);
4659 +#else
4660 + vfs_create(dtohd2(dentry)->d_inode,
4661 + meta_dentry, S_IRUSR | S_IWUSR);
4662 +#endif
4663 + }
4664 + /* open META-file for writing */
4665 + meta_file = dentry_open(meta_dentry, meta_mnt, 0x1);
4666 + if(!meta_file || IS_ERR(meta_file)) {
4667 + printk(KERN_CRIT "mini_fo: meta_write_r_entry: \
4668 + ERROR opening meta file.\n");
4669 + mntput(meta_mnt);
4670 + dput(meta_dentry);
4671 + err = -1;
4672 + goto out;
4673 + }
4674 +
4675 + /* check if fs supports writing */
4676 + if(!meta_file->f_op->write) {
4677 + printk(KERN_CRIT "mini_fo: meta_write_r_entry: \
4678 + ERROR, fs does not support writing.\n");
4679 + goto out_err_close;
4680 + }
4681 +
4682 + meta_file->f_pos = meta_dentry->d_inode->i_size; /* append */
4683 + old_fs = get_fs();
4684 + set_fs(KERNEL_DS);
4685 +
4686 + /* size: 2 for "R ", old_len+new_len for names, 1 blank+1 \n */
4687 + buf_len = old_len + new_len + 4;
4688 + buf = (char *) kmalloc(buf_len, GFP_KERNEL);
4689 + if (!buf) {
4690 + printk(KERN_CRIT "mini_fo: meta_write_r_entry: out of mem.\n");
4691 + return -ENOMEM;
4692 + }
4693 +
4694 + buf[0] = 'R';
4695 + buf[1] = ' ';
4696 + strncpy(buf + 2, old_name, old_len);
4697 + buf[old_len + 2] = ' ';
4698 + strncpy(buf + old_len + 3, new_name, new_len);
4699 + buf[buf_len -1] = '\n';
4700 + bytes = meta_file->f_op->write(meta_file, buf, buf_len, &meta_file->f_pos);
4701 + if(bytes != buf_len) {
4702 + printk(KERN_CRIT "mini_fo: meta_write_r_entry: ERROR writing.\n");
4703 + err = -1;
4704 + }
4705 +
4706 + kfree(buf);
4707 + set_fs(old_fs);
4708 +
4709 + out_err_close:
4710 + fput(meta_file);
4711 + out:
4712 + return err;
4713 +}
4714 +
4715 +/* sync D list to disk, append data if app_flag is 1 */
4716 +/* check the meta_mnt, which seems not to be used (properly) */
4717 +
4718 +int meta_sync_d_list(dentry_t *dentry, int app_flag)
4719 +{
4720 + dentry_t *meta_dentry;
4721 + file_t *meta_file;
4722 + mm_segment_t old_fs;
4723 +
4724 + int bytes, err;
4725 + struct vfsmount *meta_mnt;
4726 + char *buf;
4727 +
4728 + struct list_head *tmp;
4729 + struct deleted_entry *del_entry;
4730 + struct mini_fo_inode_info *inode_info;
4731 +
4732 + err = 0;
4733 + meta_file=0;
4734 + meta_mnt=0;
4735 +
4736 + if(!dentry || !dentry->d_inode) {
4737 + printk(KERN_CRIT "mini_fo: meta_sync_d_list: \
4738 + invalid inode passed.\n");
4739 + err = -1;
4740 + goto out;
4741 + }
4742 + inode_info = itopd(dentry->d_inode);
4743 +
4744 + if(inode_info->deleted_list_size < 0) {
4745 + err = -1;
4746 + goto out;
4747 + }
4748 +
4749 + /* ok, there is something to sync */
4750 +
4751 + /* build the storage structure? */
4752 + if(!dtohd2(dentry) && !itohi2(dentry->d_inode)) {
4753 + err = build_sto_structure(dentry->d_parent, dentry);
4754 + if(err) {
4755 + printk(KERN_CRIT "mini_fo: meta_sync_d_list: \
4756 + build_sto_structure failed.\n");
4757 + goto out;
4758 + }
4759 + }
4760 + meta_dentry = lookup_one_len(META_FILENAME,
4761 + dtohd2(dentry),
4762 + strlen(META_FILENAME));
4763 + if(!meta_dentry->d_inode) {
4764 + /* We need to create a META-file */
4765 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
4766 + vfs_create(dtohd2(dentry)->d_inode,
4767 + meta_dentry, S_IRUSR | S_IWUSR, NULL);
4768 +#else
4769 + vfs_create(dtohd2(dentry)->d_inode,
4770 + meta_dentry, S_IRUSR | S_IWUSR);
4771 +#endif
4772 + app_flag = 0;
4773 + }
4774 + /* need we truncate the meta file? */
4775 + if(!app_flag) {
4776 + struct iattr newattrs;
4777 + newattrs.ia_size = 0;
4778 + newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
4779 +
4780 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
4781 + mutex_lock(&meta_dentry->d_inode->i_mutex);
4782 +#else
4783 + down(&meta_dentry->d_inode->i_sem);
4784 +#endif
4785 + err = notify_change(meta_dentry, &newattrs);
4786 +
4787 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
4788 + mutex_unlock(&meta_dentry->d_inode->i_mutex);
4789 +#else
4790 + up(&meta_dentry->d_inode->i_sem);
4791 +#endif
4792 +
4793 + if(err || meta_dentry->d_inode->i_size != 0) {
4794 + printk(KERN_CRIT "mini_fo: meta_sync_d_list: \
4795 + ERROR truncating meta file.\n");
4796 + goto out_err_close;
4797 + }
4798 + }
4799 +
4800 + /* open META-file for writing */
4801 + meta_file = dentry_open(meta_dentry, meta_mnt, 0x1);
4802 + if(!meta_file || IS_ERR(meta_file)) {
4803 + printk(KERN_CRIT "mini_fo: meta_sync_d_list: \
4804 + ERROR opening meta file.\n");
4805 + /* we don't mntget so we dont't mntput (for now)
4806 + * mntput(meta_mnt);
4807 + */
4808 + dput(meta_dentry);
4809 + err = -1;
4810 + goto out;
4811 + }
4812 +
4813 + /* check if fs supports writing */
4814 + if(!meta_file->f_op->write) {
4815 + printk(KERN_CRIT "mini_fo: meta_sync_d_list: \
4816 + ERROR, fs does not support writing.\n");
4817 + goto out_err_close;
4818 + }
4819 +
4820 + meta_file->f_pos = meta_dentry->d_inode->i_size; /* append */
4821 + old_fs = get_fs();
4822 + set_fs(KERNEL_DS);
4823 +
4824 + /* here we go... */
4825 + list_for_each(tmp, &inode_info->deleted_list) {
4826 + del_entry = list_entry(tmp, struct deleted_entry, list);
4827 +
4828 + /* size: len for name, 1 for \n and 2 for "D " */
4829 + buf = (char *) kmalloc(del_entry->len+3, GFP_KERNEL);
4830 + if (!buf) {
4831 + printk(KERN_CRIT "mini_fo: meta_sync_d_list: \
4832 + out of mem.\n");
4833 + return -ENOMEM;
4834 + }
4835 +
4836 + buf[0] = 'D';
4837 + buf[1] = ' ';
4838 + strncpy(buf+2, del_entry->name, del_entry->len);
4839 + buf[del_entry->len+2] = '\n';
4840 + bytes = meta_file->f_op->write(meta_file, buf,
4841 + del_entry->len+3,
4842 + &meta_file->f_pos);
4843 + if(bytes != del_entry->len+3) {
4844 + printk(KERN_CRIT "mini_fo: meta_sync_d_list: \
4845 + ERROR writing.\n");
4846 + err |= -1;
4847 + }
4848 + kfree(buf);
4849 + }
4850 + set_fs(old_fs);
4851 +
4852 + out_err_close:
4853 + fput(meta_file);
4854 + out:
4855 + return err;
4856 +
4857 +}
4858 +
4859 +int meta_sync_r_list(dentry_t *dentry, int app_flag)
4860 +{
4861 + dentry_t *meta_dentry;
4862 + file_t *meta_file;
4863 + mm_segment_t old_fs;
4864 +
4865 + int bytes, err, buf_len;
4866 + struct vfsmount *meta_mnt;
4867 + char *buf;
4868 +
4869 + struct list_head *tmp;
4870 + struct renamed_entry *ren_entry;
4871 + struct mini_fo_inode_info *inode_info;
4872 +
4873 + err = 0;
4874 + meta_file=0;
4875 + meta_mnt=0;
4876 +
4877 + if(!dentry || !dentry->d_inode) {
4878 + printk(KERN_CRIT "mini_fo: meta_sync_r_list: \
4879 + invalid dentry passed.\n");
4880 + err = -1;
4881 + goto out;
4882 + }
4883 + inode_info = itopd(dentry->d_inode);
4884 +
4885 + if(inode_info->deleted_list_size < 0) {
4886 + err = -1;
4887 + goto out;
4888 + }
4889 +
4890 + /* ok, there is something to sync */
4891 +
4892 + /* build the storage structure? */
4893 + if(!dtohd2(dentry) && !itohi2(dentry->d_inode)) {
4894 + err = build_sto_structure(dentry->d_parent, dentry);
4895 + if(err) {
4896 + printk(KERN_CRIT "mini_fo: meta_sync_r_list: \
4897 + build_sto_structure failed.\n");
4898 + goto out;
4899 + }
4900 + }
4901 + meta_dentry = lookup_one_len(META_FILENAME,
4902 + dtohd2(dentry),
4903 + strlen(META_FILENAME));
4904 + if(!meta_dentry->d_inode) {
4905 + /* We need to create a META-file */
4906 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
4907 + vfs_create(dtohd2(dentry)->d_inode,
4908 + meta_dentry, S_IRUSR | S_IWUSR, NULL);
4909 +#else
4910 + vfs_create(dtohd2(dentry)->d_inode,
4911 + meta_dentry, S_IRUSR | S_IWUSR);
4912 +#endif
4913 + app_flag = 0;
4914 + }
4915 + /* need we truncate the meta file? */
4916 + if(!app_flag) {
4917 + struct iattr newattrs;
4918 + newattrs.ia_size = 0;
4919 + newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
4920 +
4921 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
4922 + mutex_lock(&meta_dentry->d_inode->i_mutex);
4923 +#else
4924 + down(&meta_dentry->d_inode->i_sem);
4925 +#endif
4926 + err = notify_change(meta_dentry, &newattrs);
4927 +
4928 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
4929 + mutex_unlock(&meta_dentry->d_inode->i_mutex);
4930 +#else
4931 + up(&meta_dentry->d_inode->i_sem);
4932 +#endif
4933 + if(err || meta_dentry->d_inode->i_size != 0) {
4934 + printk(KERN_CRIT "mini_fo: meta_sync_r_list: \
4935 + ERROR truncating meta file.\n");
4936 + goto out_err_close;
4937 + }
4938 + }
4939 +
4940 + /* open META-file for writing */
4941 + meta_file = dentry_open(meta_dentry, meta_mnt, 0x1);
4942 + if(!meta_file || IS_ERR(meta_file)) {
4943 + printk(KERN_CRIT "mini_fo: meta_sync_r_list: \
4944 + ERROR opening meta file.\n");
4945 + /* we don't mntget so we dont't mntput (for now)
4946 + * mntput(meta_mnt);
4947 + */
4948 + dput(meta_dentry);
4949 + err = -1;
4950 + goto out;
4951 + }
4952 +
4953 + /* check if fs supports writing */
4954 + if(!meta_file->f_op->write) {
4955 + printk(KERN_CRIT "mini_fo: meta_sync_r_list: \
4956 + ERROR, fs does not support writing.\n");
4957 + goto out_err_close;
4958 + }
4959 +
4960 + meta_file->f_pos = meta_dentry->d_inode->i_size; /* append */
4961 + old_fs = get_fs();
4962 + set_fs(KERNEL_DS);
4963 +
4964 + /* here we go... */
4965 + list_for_each(tmp, &inode_info->renamed_list) {
4966 + ren_entry = list_entry(tmp, struct renamed_entry, list);
4967 + /* size:
4968 + * 2 for "R ", old_len+new_len for names, 1 blank+1 \n */
4969 + buf_len = ren_entry->old_len + ren_entry->new_len + 4;
4970 + buf = (char *) kmalloc(buf_len, GFP_KERNEL);
4971 + if (!buf) {
4972 + printk(KERN_CRIT "mini_fo: meta_sync_r_list: \
4973 + out of mem.\n");
4974 + return -ENOMEM;
4975 + }
4976 + buf[0] = 'R';
4977 + buf[1] = ' ';
4978 + strncpy(buf + 2, ren_entry->old_name, ren_entry->old_len);
4979 + buf[ren_entry->old_len + 2] = ' ';
4980 + strncpy(buf + ren_entry->old_len + 3,
4981 + ren_entry->new_name, ren_entry->new_len);
4982 + buf[buf_len - 1] = '\n';
4983 + bytes = meta_file->f_op->write(meta_file, buf,
4984 + buf_len, &meta_file->f_pos);
4985 + if(bytes != buf_len) {
4986 + printk(KERN_CRIT "mini_fo: meta_sync_r_list: \
4987 + ERROR writing.\n");
4988 + err |= -1;
4989 + }
4990 + kfree(buf);
4991 + }
4992 + set_fs(old_fs);
4993 +
4994 + out_err_close:
4995 + fput(meta_file);
4996 + out:
4997 + return err;
4998 +}
4999 +
5000 +int meta_check_d_entry(dentry_t *dentry, const char *name, int len)
5001 +{
5002 + if(!dentry || !dentry->d_inode)
5003 + printk(KERN_CRIT "mini_fo: meta_check_d_dentry: \
5004 + invalid dentry passed.\n");
5005 + return __meta_check_d_entry(dentry->d_inode, name, len);
5006 +}
5007 +
5008 +int __meta_check_d_entry(inode_t *inode, const char *name, int len)
5009 +{
5010 + struct list_head *tmp;
5011 + struct deleted_entry *del_entry;
5012 + struct mini_fo_inode_info *inode_info;
5013 +
5014 + if(!inode || !itopd(inode))
5015 + printk(KERN_CRIT "mini_fo: __meta_check_d_dentry: \
5016 + invalid inode passed.\n");
5017 +
5018 + inode_info = itopd(inode);
5019 +
5020 + if(inode_info->deleted_list_size <= 0)
5021 + return 0;
5022 +
5023 + list_for_each(tmp, &inode_info->deleted_list) {
5024 + del_entry = list_entry(tmp, struct deleted_entry, list);
5025 + if(del_entry->len != len)
5026 + continue;
5027 +
5028 + if(!strncmp(del_entry->name, name, len))
5029 + return 1;
5030 + }
5031 + return 0;
5032 +}
5033 +
5034 +/*
5035 + * check if file has been renamed and return path to orig. base dir.
5036 + * Implements no error return values so far, what of course sucks.
5037 + * String is null terminated.'
5038 + */
5039 +char* meta_check_r_entry(dentry_t *dentry, const char *name, int len)
5040 +{
5041 + if(!dentry || !dentry->d_inode) {
5042 + printk(KERN_CRIT "mini_fo: meta_check_r_dentry: \
5043 + invalid dentry passed.\n");
5044 + return NULL;
5045 + }
5046 + return __meta_check_r_entry(dentry->d_inode, name, len);
5047 +}
5048 +
5049 +char* __meta_check_r_entry(inode_t *inode, const char *name, int len)
5050 +{
5051 + struct list_head *tmp;
5052 + struct renamed_entry *ren_entry;
5053 + struct mini_fo_inode_info *inode_info;
5054 + char *old_path;
5055 +
5056 + if(!inode || !itopd(inode)) {
5057 + printk(KERN_CRIT "mini_fo: meta_check_r_dentry: \
5058 + invalid inode passed.\n");
5059 + return NULL;
5060 + }
5061 + inode_info = itopd(inode);
5062 +
5063 + if(inode_info->renamed_list_size <= 0)
5064 + return NULL;
5065 +
5066 + list_for_each(tmp, &inode_info->renamed_list) {
5067 + ren_entry = list_entry(tmp, struct renamed_entry, list);
5068 + if(ren_entry->new_len != len)
5069 + continue;
5070 +
5071 + if(!strncmp(ren_entry->new_name, name, len)) {
5072 + old_path = (char *)
5073 + kmalloc(ren_entry->old_len+1, GFP_KERNEL);
5074 + strncpy(old_path,
5075 + ren_entry->old_name,
5076 + ren_entry->old_len);
5077 + old_path[ren_entry->old_len]='\0';
5078 + return old_path;
5079 + }
5080 + }
5081 + return NULL;
5082 +}
5083 +
5084 +/*
5085 + * This version only checks if entry exists and return:
5086 + * 1 if exists,
5087 + * 0 if not,
5088 + * -1 if error.
5089 + */
5090 +int meta_is_r_entry(dentry_t *dentry, const char *name, int len)
5091 +{
5092 + if(!dentry || !dentry->d_inode) {
5093 + printk(KERN_CRIT "mini_fo: meta_check_r_dentry [2]: \
5094 + invalid dentry passed.\n");
5095 + return -1;
5096 + }
5097 + return __meta_is_r_entry(dentry->d_inode, name, len);
5098 +}
5099 +
5100 +int __meta_is_r_entry(inode_t *inode, const char *name, int len)
5101 +{
5102 + struct list_head *tmp;
5103 + struct renamed_entry *ren_entry;
5104 + struct mini_fo_inode_info *inode_info;
5105 +
5106 + if(!inode || !itopd(inode)) {
5107 + printk(KERN_CRIT "mini_fo: meta_check_r_dentry [2]: \
5108 + invalid inode passed.\n");
5109 + return -1;
5110 + }
5111 + inode_info = itopd(inode);
5112 +
5113 + if(inode_info->renamed_list_size <= 0)
5114 + return -1;
5115 +
5116 + list_for_each(tmp, &inode_info->renamed_list) {
5117 + ren_entry = list_entry(tmp, struct renamed_entry, list);
5118 + if(ren_entry->new_len != len)
5119 + continue;
5120 +
5121 + if(!strncmp(ren_entry->new_name, name, len))
5122 + return 1;
5123 + }
5124 + return 0;
5125 +}
5126 +
5127 --- /dev/null
5128 +++ b/fs/mini_fo/mini_fo.h
5129 @@ -0,0 +1,503 @@
5130 +/*
5131 + * Copyright (c) 1997-2003 Erez Zadok
5132 + * Copyright (c) 2001-2003 Stony Brook University
5133 + *
5134 + * For specific licensing information, see the COPYING file distributed with
5135 + * this package, or get one from ftp://ftp.filesystems.org/pub/fist/COPYING.
5136 + *
5137 + * This Copyright notice must be kept intact and distributed with all
5138 + * fistgen sources INCLUDING sources generated by fistgen.
5139 + */
5140 +/*
5141 + * Copyright (C) 2004, 2005 Markus Klotzbuecher <mk@creamnet.de>
5142 + *
5143 + * This program is free software; you can redistribute it and/or
5144 + * modify it under the terms of the GNU General Public License
5145 + * as published by the Free Software Foundation; either version
5146 + * 2 of the License, or (at your option) any later version.
5147 + */
5148 +
5149 +/*
5150 + * $Id$
5151 + */
5152 +
5153 +#ifndef __MINI_FO_H_
5154 +#define __MINI_FO_H_
5155 +
5156 +#ifdef __KERNEL__
5157 +
5158 +/* META stuff */
5159 +#define META_FILENAME "META_dAfFgHE39ktF3HD2sr"
5160 +
5161 +/* use xattrs? */
5162 +#define XATTR
5163 +
5164 +/* File attributes that when changed, result in a file beeing copied to storage */
5165 +#define COPY_FLAGS ATTR_MODE | ATTR_UID | ATTR_GID | ATTR_SIZE
5166 +
5167 +/*
5168 + * mini_fo filestates
5169 + */
5170 +#define MODIFIED 1
5171 +#define UNMODIFIED 2
5172 +#define CREATED 3
5173 +#define DEL_REWRITTEN 4
5174 +#define DELETED 5
5175 +#define NON_EXISTANT 6
5176 +
5177 +/* fist file systems superblock magic */
5178 +# define MINI_FO_SUPER_MAGIC 0xf15f
5179 +
5180 +/*
5181 + * STRUCTURES:
5182 + */
5183 +
5184 +/* mini_fo inode data in memory */
5185 +struct mini_fo_inode_info {
5186 + inode_t *wii_inode;
5187 + inode_t *wii_inode2; /* pointer to storage inode */
5188 +
5189 + /* META-data lists */
5190 + /* deleted list, ex wol */
5191 + struct list_head deleted_list;
5192 + int deleted_list_size;
5193 +
5194 + /* renamed list */
5195 + struct list_head renamed_list;
5196 + int renamed_list_size;
5197 +
5198 + /* add other lists here ... */
5199 +};
5200 +
5201 +/* mini_fo dentry data in memory */
5202 +struct mini_fo_dentry_info {
5203 + dentry_t *wdi_dentry;
5204 + dentry_t *wdi_dentry2; /* pointer to storage dentry */
5205 + unsigned int state; /* state of the mini_fo dentry */
5206 +};
5207 +
5208 +
5209 +/* mini_fo super-block data in memory */
5210 +struct mini_fo_sb_info {
5211 + super_block_t *wsi_sb, *wsi_sb2; /* mk: might point to the same sb */
5212 + struct vfsmount *hidden_mnt, *hidden_mnt2;
5213 + dentry_t *base_dir_dentry;
5214 + dentry_t *storage_dir_dentry;
5215 + ;
5216 +};
5217 +
5218 +/* readdir_data, readdir helper struct */
5219 +struct readdir_data {
5220 + struct list_head ndl_list; /* linked list head ptr */
5221 + int ndl_size; /* list size */
5222 + int sto_done; /* flag to show that the storage dir entries have
5223 + * all been read an now follow base entries */
5224 +};
5225 +
5226 +/* file private data. */
5227 +struct mini_fo_file_info {
5228 + struct file *wfi_file;
5229 + struct file *wfi_file2; /* pointer to storage file */
5230 + struct readdir_data rd;
5231 +};
5232 +
5233 +/* struct ndl_entry */
5234 +struct ndl_entry {
5235 + struct list_head list;
5236 + char *name;
5237 + int len;
5238 +};
5239 +
5240 +/********************************
5241 + * META-data structures
5242 + ********************************/
5243 +
5244 +/* deleted entry */
5245 +struct deleted_entry {
5246 + struct list_head list;
5247 + char *name;
5248 + int len;
5249 +};
5250 +
5251 +/* renamed entry */
5252 +struct renamed_entry {
5253 + struct list_head list;
5254 + char *old_name; /* old directory with full path */
5255 + int old_len; /* length of above string */
5256 + char *new_name; /* new directory name */
5257 + int new_len; /* length of above string */
5258 +};
5259 +
5260 +/* attr_change entry */
5261 +struct attr_change_entry {
5262 + struct list_head list;
5263 + char *name;
5264 + int len;
5265 +};
5266 +
5267 +/* link entry */
5268 +struct link_entry {
5269 + struct list_head list;
5270 + int links_moved;
5271 + int inum_base;
5272 + int inum_sto;
5273 + char *weird_name;
5274 + int weird_name_len;
5275 +};
5276 +
5277 +
5278 +/* Some other stuff required for mini_fo_filldir64, copied from
5279 + * fs/readdir.c
5280 + */
5281 +
5282 +#define ROUND_UP64(x) (((x)+sizeof(u64)-1) & ~(sizeof(u64)-1))
5283 +#define NAME_OFFSET(de) ((int) ((de)->d_name - (char *) (de)))
5284 +
5285 +
5286 +struct linux_dirent64 {
5287 + u64 d_ino;
5288 + s64 d_off;
5289 + unsigned short d_reclen;
5290 + unsigned char d_type;
5291 + char d_name[0];
5292 +};
5293 +
5294 +
5295 +struct getdents_callback64 {
5296 + struct linux_dirent64 * current_dir;
5297 + struct linux_dirent64 * previous;
5298 + int count;
5299 + int error;
5300 +};
5301 +
5302 +struct linux_dirent {
5303 + unsigned long d_ino;
5304 + unsigned long d_off;
5305 + unsigned short d_reclen;
5306 + char d_name[1];
5307 +};
5308 +
5309 +struct getdents_callback {
5310 + struct linux_dirent * current_dir;
5311 + struct linux_dirent * previous;
5312 + int count;
5313 + int error;
5314 +};
5315 +
5316 +
5317 +/*
5318 + * MACROS:
5319 + */
5320 +
5321 +/* file TO private_data */
5322 +# define ftopd(file) ((struct mini_fo_file_info *)((file)->private_data))
5323 +# define __ftopd(file) ((file)->private_data)
5324 +/* file TO hidden_file */
5325 +# define ftohf(file) ((ftopd(file))->wfi_file)
5326 +# define ftohf2(file) ((ftopd(file))->wfi_file2)
5327 +
5328 +/* inode TO private_data */
5329 +# define itopd(ino) ((struct mini_fo_inode_info *)(ino)->u.generic_ip)
5330 +# define __itopd(ino) ((ino)->u.generic_ip)
5331 +/* inode TO hidden_inode */
5332 +# define itohi(ino) (itopd(ino)->wii_inode)
5333 +# define itohi2(ino) (itopd(ino)->wii_inode2)
5334 +
5335 +/* superblock TO private_data */
5336 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
5337 +# define stopd(super) ((struct mini_fo_sb_info *)(super)->s_fs_info)
5338 +# define __stopd(super) ((super)->s_fs_info)
5339 +#else
5340 +# define stopd(super) ((struct mini_fo_sb_info *)(super)->u.generic_sbp)
5341 +# define __stopd(super) ((super)->u.generic_sbp)
5342 +#endif
5343 +
5344 +/* unused? # define vfs2priv stopd */
5345 +/* superblock TO hidden_superblock */
5346 +
5347 +# define stohs(super) (stopd(super)->wsi_sb)
5348 +# define stohs2(super) (stopd(super)->wsi_sb2)
5349 +
5350 +/* dentry TO private_data */
5351 +# define dtopd(dentry) ((struct mini_fo_dentry_info *)(dentry)->d_fsdata)
5352 +# define __dtopd(dentry) ((dentry)->d_fsdata)
5353 +/* dentry TO hidden_dentry */
5354 +# define dtohd(dent) (dtopd(dent)->wdi_dentry)
5355 +# define dtohd2(dent) (dtopd(dent)->wdi_dentry2)
5356 +
5357 +/* dentry to state */
5358 +# define dtost(dent) (dtopd(dent)->state)
5359 +# define sbt(sb) ((sb)->s_type->name)
5360 +
5361 +#define IS_WRITE_FLAG(flag) (flag & (O_RDWR | O_WRONLY | O_APPEND))
5362 +#define IS_COPY_FLAG(flag) (flag & (COPY_FLAGS))
5363 +
5364 +/* macros to simplify non-SCA code */
5365 +# define MALLOC_PAGE_POINTERS(hidden_pages, num_hidden_pages)
5366 +# define MALLOC_PAGEDATA_POINTERS(hidden_pages_data, num_hidden_pages)
5367 +# define FREE_PAGE_POINTERS(hidden_pages, num)
5368 +# define FREE_PAGEDATA_POINTERS(hidden_pages_data, num)
5369 +# define FOR_EACH_PAGE
5370 +# define CURRENT_HIDDEN_PAGE hidden_page
5371 +# define CURRENT_HIDDEN_PAGEDATA hidden_page_data
5372 +# define CURRENT_HIDDEN_PAGEINDEX page->index
5373 +
5374 +/*
5375 + * EXTERNALS:
5376 + */
5377 +extern struct file_operations mini_fo_main_fops;
5378 +extern struct file_operations mini_fo_dir_fops;
5379 +extern struct inode_operations mini_fo_main_iops;
5380 +extern struct inode_operations mini_fo_dir_iops;
5381 +extern struct inode_operations mini_fo_symlink_iops;
5382 +extern struct super_operations mini_fo_sops;
5383 +extern struct dentry_operations mini_fo_dops;
5384 +extern struct vm_operations_struct mini_fo_shared_vmops;
5385 +extern struct vm_operations_struct mini_fo_private_vmops;
5386 +extern struct address_space_operations mini_fo_aops;
5387 +
5388 +#if 0 /* unused by mini_fo */
5389 +extern int mini_fo_interpose(dentry_t *hidden_dentry, dentry_t *this_dentry, super_block_t *sb, int flag);
5390 +#if defined(FIST_FILTER_DATA) || defined(FIST_FILTER_SCA)
5391 +extern page_t *mini_fo_get1page(file_t *file, int index);
5392 +extern int mini_fo_fill_zeros(file_t *file, page_t *page, unsigned from);
5393 +# endif /* FIST_FILTER_DATA || FIST_FILTER_SCA */
5394 +
5395 +
5396 +# define mini_fo_hidden_dentry(d) __mini_fo_hidden_dentry(__FILE__,__FUNCTION__,__LINE__,(d))
5397 +# define mini_fo_hidden_sto_dentry(d) __mini_fo_hidden_sto_dentry(__FILE__,__FUNCTION__,__LINE__,(d))
5398 +
5399 +extern dentry_t *__mini_fo_hidden_dentry(char *file, char *func, int line, dentry_t *this_dentry);
5400 +extern dentry_t *__mini_fo_hidden_sto_dentry(char *file, char *func, int line, dentry_t *this_dentry);
5401 +
5402 +extern int mini_fo_read_file(const char *filename, void *buf, int len);
5403 +extern int mini_fo_write_file(const char *filename, void *buf, int len);
5404 +extern dentry_t *fist_lookup(dentry_t *dir, const char *name, vnode_t **out, uid_t uid, gid_t gid);
5405 +#endif /* unused by mini_fo */
5406 +
5407 +/* state transition functions */
5408 +extern int nondir_unmod_to_mod(dentry_t *dentry, int cp_flag);
5409 +extern int nondir_del_rew_to_del(dentry_t *dentry);
5410 +extern int nondir_creat_to_del(dentry_t *dentry);
5411 +extern int nondir_mod_to_del(dentry_t *dentry);
5412 +extern int nondir_unmod_to_del(dentry_t *dentry);
5413 +
5414 +extern int dir_unmod_to_mod(dentry_t *dentry);
5415 +
5416 +/* rename specials */
5417 +extern int rename_directory(inode_t *old_dir, dentry_t *old_dentry, inode_t *new_dir, dentry_t *new_dentry);
5418 +extern int rename_nondir(inode_t *old_dir, dentry_t *old_dentry, inode_t *new_dir, dentry_t *new_dentry);
5419 +
5420 +/* misc stuff */
5421 +extern int mini_fo_tri_interpose(dentry_t *hidden_dentry,
5422 + dentry_t *hidden_sto_dentry,
5423 + dentry_t *dentry,
5424 + super_block_t *sb, int flag);
5425 +
5426 +extern int mini_fo_cp_cont(dentry_t *tgt_dentry, struct vfsmount *tgt_mnt,
5427 + dentry_t *src_dentry, struct vfsmount *src_mnt);
5428 +
5429 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
5430 +extern int mini_fo_create(inode_t *dir, dentry_t *dentry, int mode, struct nameidata *nd);
5431 +
5432 +extern int create_sto_nod(dentry_t *dentry, int mode, dev_t dev);
5433 +extern int create_sto_reg_file(dentry_t *dentry, int mode, struct nameidata *nd);
5434 +#else
5435 +extern int mini_fo_create(inode_t *dir, dentry_t *dentry, int mode);
5436 +
5437 +extern int create_sto_nod(dentry_t *dentry, int mode, int dev);
5438 +extern int create_sto_reg_file(dentry_t *dentry, int mode);
5439 +#endif
5440 +
5441 +extern int create_sto_dir(dentry_t *dentry, int mode);
5442 +
5443 +extern int exists_in_storage(dentry_t *dentry);
5444 +extern int is_mini_fo_existant(dentry_t *dentry);
5445 +extern int get_neg_sto_dentry(dentry_t *dentry);
5446 +extern int build_sto_structure(dentry_t *dir, dentry_t *dentry);
5447 +extern int get_mini_fo_bpath(dentry_t *dentry, char **bpath, int *bpath_len);
5448 +extern dentry_t *bpath_walk(super_block_t *sb, char *bpath);
5449 +extern int bpath_put(dentry_t *dentry);
5450 +
5451 +/* check_mini_fo types functions */
5452 +extern int check_mini_fo_dentry(dentry_t *dentry);
5453 +extern int check_mini_fo_file(file_t *file);
5454 +extern int check_mini_fo_inode(inode_t *inode);
5455 +
5456 +/* General meta functions, can be called from outside of meta.c */
5457 +extern int meta_build_lists(dentry_t *dentry);
5458 +extern int meta_put_lists(dentry_t *dentry);
5459 +extern int __meta_put_lists(inode_t *inode);
5460 +
5461 +extern int meta_add_d_entry(dentry_t *dentry, const char *name, int len);
5462 +extern int meta_add_r_entry(dentry_t *dentry,
5463 + const char *old_name, int old_len,
5464 + const char *new_name, int new_len);
5465 +
5466 +extern int meta_remove_r_entry(dentry_t *dentry, const char *name, int len);
5467 +
5468 +extern int meta_check_d_entry(dentry_t *dentry, const char *name, int len);
5469 +extern int __meta_check_d_entry(inode_t *inode, const char *name, int len);
5470 +
5471 +extern char* meta_check_r_entry(dentry_t *dentry, const char *name, int len);
5472 +extern char* __meta_check_r_entry(inode_t *inode, const char *name, int len);
5473 +extern int meta_is_r_entry(dentry_t *dentry, const char *name, int len);
5474 +extern int __meta_is_r_entry(inode_t *inode, const char *name, int len);
5475 +
5476 +/* Specific meta functions, should be called only inside meta.c */
5477 +extern int __meta_put_d_list(inode_t *inode);
5478 +extern int __meta_put_r_list(inode_t *inode);
5479 +
5480 +extern int meta_list_add_d_entry(dentry_t *dentry,
5481 + const char *name, int len);
5482 +extern int meta_list_add_r_entry(dentry_t *dentry,
5483 + const char *old_name, int old_len,
5484 + const char *new_name, int new_len);
5485 +
5486 +extern int meta_list_remove_r_entry(dentry_t *dentry,
5487 + const char *name, int len);
5488 +
5489 +extern int __meta_list_remove_r_entry(inode_t *inode,
5490 + const char *name, int len);
5491 +
5492 +extern int meta_write_d_entry(dentry_t *dentry, const char *name, int len);
5493 +extern int meta_write_r_entry(dentry_t *dentry,
5494 + const char *old_name, int old_len,
5495 + const char *new_name, int new_len);
5496 +
5497 +extern int meta_sync_lists(dentry_t *dentry);
5498 +extern int meta_sync_d_list(dentry_t *dentry, int app_flag);
5499 +extern int meta_sync_r_list(dentry_t *dentry, int app_flag);
5500 +
5501 +/* ndl stuff */
5502 +extern int ndl_add_entry(struct readdir_data *rd, const char *name, int len);
5503 +extern void ndl_put_list(struct readdir_data *rd);
5504 +extern int ndl_check_entry(struct readdir_data *rd,
5505 + const char *name, int len);
5506 +
5507 +
5508 +# define copy_inode_size(dst, src) \
5509 + dst->i_size = src->i_size; \
5510 + dst->i_blocks = src->i_blocks;
5511 +
5512 +static inline void
5513 +fist_copy_attr_atime(inode_t *dest, const inode_t *src)
5514 +{
5515 + ASSERT(dest != NULL);
5516 + ASSERT(src != NULL);
5517 + dest->i_atime = src->i_atime;
5518 +}
5519 +static inline void
5520 +fist_copy_attr_times(inode_t *dest, const inode_t *src)
5521 +{
5522 + ASSERT(dest != NULL);
5523 + ASSERT(src != NULL);
5524 + dest->i_atime = src->i_atime;
5525 + dest->i_mtime = src->i_mtime;
5526 + dest->i_ctime = src->i_ctime;
5527 +}
5528 +static inline void
5529 +fist_copy_attr_timesizes(inode_t *dest, const inode_t *src)
5530 +{
5531 + ASSERT(dest != NULL);
5532 + ASSERT(src != NULL);
5533 + dest->i_atime = src->i_atime;
5534 + dest->i_mtime = src->i_mtime;
5535 + dest->i_ctime = src->i_ctime;
5536 + copy_inode_size(dest, src);
5537 +}
5538 +static inline void
5539 +fist_copy_attr_all(inode_t *dest, const inode_t *src)
5540 +{
5541 + ASSERT(dest != NULL);
5542 + ASSERT(src != NULL);
5543 + dest->i_mode = src->i_mode;
5544 + dest->i_nlink = src->i_nlink;
5545 + dest->i_uid = src->i_uid;
5546 + dest->i_gid = src->i_gid;
5547 + dest->i_rdev = src->i_rdev;
5548 + dest->i_atime = src->i_atime;
5549 + dest->i_mtime = src->i_mtime;
5550 + dest->i_ctime = src->i_ctime;
5551 + dest->i_blksize = src->i_blksize;
5552 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,12)
5553 + dest->i_blkbits = src->i_blkbits;
5554 +# endif /* linux 2.4.12 and newer */
5555 + copy_inode_size(dest, src);
5556 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
5557 + dest->i_attr_flags = src->i_attr_flags;
5558 +#else
5559 + dest->i_flags = src->i_flags;
5560 +#endif
5561 +}
5562 +
5563 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
5564 +/* copied from linux/fs.h */
5565 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
5566 +static inline void double_lock(struct dentry *d1, struct dentry *d2)
5567 +{
5568 + struct mutex *m1 = &d1->d_inode->i_mutex;
5569 + struct mutex *m2 = &d2->d_inode->i_mutex;
5570 + if (m1 != m2) {
5571 + if ((unsigned long) m1 < (unsigned long) m2) {
5572 + struct mutex *tmp = m2;
5573 + m2 = m1; m1 = tmp;
5574 + }
5575 + mutex_lock(m1);
5576 + }
5577 + mutex_lock(m2);
5578 +}
5579 +
5580 +static inline void double_unlock(struct dentry *d1, struct dentry *d2)
5581 +{
5582 + struct mutex *m1 = &d1->d_inode->i_mutex;
5583 + struct mutex *m2 = &d2->d_inode->i_mutex;
5584 + mutex_unlock(m1);
5585 + if (m1 != m2)
5586 + mutex_unlock(m2);
5587 + dput(d1);
5588 + dput(d2);
5589 +}
5590 +
5591 +#else
5592 +static inline void double_down(struct semaphore *s1, struct semaphore *s2)
5593 +{
5594 + if (s1 != s2) {
5595 + if ((unsigned long) s1 < (unsigned long) s2) {
5596 + struct semaphore *tmp = s2;
5597 + s2 = s1; s1 = tmp;
5598 + }
5599 + down(s1);
5600 + }
5601 + down(s2);
5602 +}
5603 +
5604 +static inline void double_up(struct semaphore *s1, struct semaphore *s2)
5605 +{
5606 + up(s1);
5607 + if (s1 != s2)
5608 + up(s2);
5609 +}
5610 +
5611 +static inline void double_lock(struct dentry *d1, struct dentry *d2)
5612 +{
5613 + double_down(&d1->d_inode->i_sem, &d2->d_inode->i_sem);
5614 +}
5615 +
5616 +static inline void double_unlock(struct dentry *d1, struct dentry *d2)
5617 +{
5618 + double_up(&d1->d_inode->i_sem,&d2->d_inode->i_sem);
5619 + dput(d1);
5620 + dput(d2);
5621 +}
5622 +#endif /* if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16) */
5623 +#endif /* if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) */
5624 +#endif /* __KERNEL__ */
5625 +
5626 +/*
5627 + * Definitions for user and kernel code
5628 + */
5629 +
5630 +/* ioctls */
5631 +
5632 +#endif /* not __MINI_FO_H_ */
5633 --- /dev/null
5634 +++ b/fs/mini_fo/mini_fo-merge
5635 @@ -0,0 +1,180 @@
5636 +#!/bin/bash
5637 +#
5638 +# Copyright (C) 2005 Markus Klotzbuecher <mk@creamnet.de>
5639 +# This program is free software; you can redistribute it and/or
5640 +# modify it under the terms of the GNU General Public License
5641 +# as published by the Free Software Foundation; either version
5642 +# 2 of the License, or (at your option) any later version.
5643 +#
5644 +
5645 +BASE=
5646 +STO=
5647 +HELP=
5648 +DRYRUN=
5649 +VERBOSE=
5650 +TMP="/tmp/"
5651 +META_NAME="META_dAfFgHE39ktF3HD2sr"
5652 +SKIP_DEL_LIST="skip-delete-list.mini_fo-merge"
5653 +
5654 +COMMAND=
5655 +exec_command()
5656 +{
5657 + if [ x$DRYRUN == "xset" ]; then
5658 + echo " would run: $COMMAND"
5659 + elif ! [ x$DRYRUN == "xset" ]; then
5660 + if [ x$VERBOSE == "xset" ]; then
5661 + echo " running: $COMMAND"
5662 + fi
5663 + eval $COMMAND
5664 + fi
5665 +}
5666 +
5667 +usage()
5668 +{
5669 +cat <<EOF
5670 +
5671 +USAGE: $0 -b <base dir> -s <storage dir>
5672 +Version 0.1
5673 +
5674 +This script merges the contents of a mini_fo storage file system back
5675 +to the base file system.
5676 +
5677 +!!! Warning: This will modify the base filesystem and can destroy data
5678 + if used wrongly.
5679 +
5680 +Options:
5681 + -b <base dir>
5682 + the directory of the base file system.
5683 +
5684 + -s <storage dir>
5685 + the directory of the storage file system.
5686 +
5687 + -d dry run, will not change anything and print the commands that
5688 + would be executed.
5689 +
5690 + -t tmp dir for storing temporary file. default: $TMP
5691 +
5692 + -v show what operations are performed.
5693 +
5694 + -h displays this message.
5695 +
5696 +EOF
5697 +}
5698 +
5699 +# parse parameters
5700 +while getopts hdvt:b:s: OPTS
5701 + do
5702 + case $OPTS in
5703 + h) HELP="set";;
5704 + d) DRYRUN="set";;
5705 + v) VERBOSE="set";;
5706 + b) BASE="$OPTARG";;
5707 + s) STO="$OPTARG";;
5708 + t) TMP="$OPTARG";;
5709 + ?) usage
5710 + exit 1;;
5711 + esac
5712 +done
5713 +
5714 +if [ "x$HELP" == "xset" ]; then
5715 + usage
5716 + exit -1
5717 +fi
5718 +
5719 +if ! [ -d "$BASE" ] || ! [ -d "$STO" ]; then
5720 + echo -e "$0:\n Error, -s and/or -b argument missing. type $0 -h for help."
5721 + exit -1;
5722 +fi
5723 +
5724 +# get full paths
5725 +pushd $STO; STO=`pwd`; popd
5726 +pushd $BASE; BASE=`pwd`; popd
5727 +TMP=${TMP%/}
5728 +
5729 +
5730 +cat<<EOF
5731 +###############################################################################
5732 +# mini_fo-merge
5733 +#
5734 +# base dir: $BASE
5735 +# storage dir: $STO
5736 +# meta filename: $META_NAME
5737 +# dry run: $DRYRUN
5738 +# verbose: $VERBOSE
5739 +# tmp files: $TMP
5740 +###############################################################################
5741 +
5742 +EOF
5743 +
5744 +rm $TMP/$SKIP_DEL_LIST
5745 +
5746 +# first process all renamed dirs
5747 +echo "Merging renamed directories..."
5748 +pushd $STO &> /dev/null
5749 +find . -name $META_NAME -type f -print0 | xargs -0 -e grep -e '^R ' | tr -s ':R' ' ' | while read ENTRY; do
5750 + echo "entry: $ENTRY"
5751 + META_FILE=`echo $ENTRY | cut -d ' ' -f 1`
5752 + OLD_B_DIR=`echo $ENTRY | cut -d ' ' -f 2 | sed -e 's/\///'`
5753 + NEW_NAME=`echo $ENTRY | cut -d ' ' -f 3`
5754 + NEW_B_DIR=`echo $META_FILE | sed -e "s/$META_NAME/$NEW_NAME/" | sed -e 's/^\.\///'`
5755 + echo "META_FILE: $META_FILE"
5756 + echo "OLD_B_DIR: $OLD_B_DIR"
5757 + echo "NEW_NAME: $NEW_NAME"
5758 + echo "NEW_B_DIR: $NEW_B_DIR"
5759 +
5760 + pushd $BASE &> /dev/null
5761 + # remove an existing dir in storage
5762 + COMMAND="rm -rf $NEW_B_DIR"; exec_command
5763 + COMMAND="cp -R $OLD_B_DIR $NEW_B_DIR"; exec_command
5764 + echo ""
5765 + popd &> /dev/null
5766 +
5767 + # remember this dir to exclude it from deleting later
5768 + echo $NEW_B_DIR >> $TMP/$SKIP_DEL_LIST
5769 +done
5770 +
5771 +# delete all whiteouted files from base
5772 +echo -e "\nDeleting whiteout'ed files from base file system..."
5773 +find . -name $META_NAME -type f -print0 | xargs -0 -e grep -e '^D ' | sed -e 's/:D//' | while read ENTRY; do
5774 + META_FILE=`echo $ENTRY | cut -d ' ' -f 1`
5775 + DEL_NAME=`echo $ENTRY | cut -d ' ' -f 2`
5776 + DEL_FILE=`echo $META_FILE | sed -e "s/$META_NAME/$DEL_NAME/" | sed -e 's/^\.\///'`
5777 + grep -x $DEL_FILE $TMP/$SKIP_DEL_LIST &> /dev/null
5778 + if [ $? -ne 0 ]; then
5779 + pushd $BASE &> /dev/null
5780 + COMMAND="rm -rf $DEL_FILE"; exec_command
5781 + popd &> /dev/null
5782 + else
5783 + echo " excluding: $DEL_FILE as in skip-del-list."
5784 + fi
5785 +done
5786 +
5787 +# create all dirs and update permissions
5788 +echo -e "\nSetting up directory structures in base file system..."
5789 +find . -type d | sed -e 's/^\.\///' | while read DIR; do
5790 + PERMS=`stat -c %a $DIR`
5791 + DIR_UID=`stat -c %u $DIR`
5792 + DIR_GID=`stat -c %g $DIR`
5793 + pushd $BASE &> /dev/null
5794 + if ! [ -d $DIR ]; then
5795 + COMMAND="mkdir -p $DIR"; exec_command
5796 + fi
5797 + COMMAND="chmod $PERMS $DIR"; exec_command
5798 + COMMAND="chown $DIR_UID:$DIR_GID $DIR"; exec_command
5799 + popd &> /dev/null
5800 +done
5801 +
5802 +# merge all non-directory files
5803 +echo -e "\nMerging all non-directory files...."
5804 +for i in b c p f l s; do
5805 + find . -type $i | sed -e 's/^\.\///' | grep -v "$META_NAME" | while read FILE; do
5806 + pushd $BASE #&> /dev/null
5807 + COMMAND="cp -df $STO/$FILE $BASE/$FILE"; exec_command
5808 + popd &> /dev/null
5809 + done
5810 +done
5811 +popd &> /dev/null
5812 +
5813 +#rm $TMP/$SKIP_DEL_LIST
5814 +
5815 +echo "Done!"
5816 --- /dev/null
5817 +++ b/fs/mini_fo/mini_fo-overlay
5818 @@ -0,0 +1,130 @@
5819 +#!/bin/bash
5820 +#
5821 +# Copyright (C) 2005 Markus Klotzbuecher <mk@creamnet.de>
5822 +# This program is free software; you can redistribute it and/or
5823 +# modify it under the terms of the GNU General Public License
5824 +# as published by the Free Software Foundation; either version
5825 +# 2 of the License, or (at your option) any later version.
5826 +#
5827 +
5828 +HELP=
5829 +SUFF=
5830 +MNTP=
5831 +MNT_DIR="/mnt"
5832 +STO=
5833 +STO_DIR="/tmp"
5834 +BASE=
5835 +
5836 +usage()
5837 +{
5838 +cat <<EOF
5839 +
5840 +Usage: $0 [-s suffix] [-d sto_dir_dir] [-m mount point] base_dir
5841 +Version 0.1
5842 +
5843 +This script overlays the given base directory using the mini_fo file
5844 +system. If only the base directory base_dir is given, $0
5845 +will use a storage directory called "sto-<base_dir_name>" in $STO_DIR,
5846 +and mount point "mini_fo-<base_dir_dir>" in $MNT_DIR.
5847 +
5848 +Options:
5849 + -s <suffix>
5850 + add given suffix to storage directory and the mount
5851 + point. This is usefull for overlaying one base directory
5852 + several times and avoiding conflicts with storage directory
5853 + names and mount points.
5854 +
5855 + -d <sto_dir_dir>
5856 + change the directory in which the storage directory will be
5857 + created (default is currently "$STO_DIR".
5858 +
5859 + -m <mount point>
5860 + use an alternative directory to create the mini_fo
5861 + mountpoint (default is currently "$MNT_DIR".
5862 +
5863 + -h displays this message.
5864 +
5865 +EOF
5866 +exit 1;
5867 +}
5868 +
5869 +while getopts hm:s:d: OPTS
5870 + do
5871 + case $OPTS in
5872 + s) SUFF="$OPTARG";;
5873 + d) STO_DIR="$OPTARG";;
5874 + m) MNT_DIR="$OPTARG";;
5875 + h) HELP="set";;
5876 + ?) usage
5877 + exit 1;;
5878 + esac
5879 +done
5880 +shift $(($OPTIND - 1))
5881 +
5882 +BASE="$1"
5883 +
5884 +if [ "x$HELP" == "xset" ]; then
5885 + usage
5886 + exit -1
5887 +fi
5888 +
5889 +# fix suffix
5890 +if [ "x$SUFF" != "x" ]; then
5891 + SUFF="-$SUFF"
5892 +fi
5893 +
5894 +# kill trailing slashes
5895 +MNT_DIR=${MNT_DIR%/}
5896 +STO_DIR=${STO_DIR%/}
5897 +BASE=${BASE%/}
5898 +
5899 +
5900 +if ! [ -d "$BASE" ]; then
5901 + echo "invalid base dir $BASE, run $0 -h for help."
5902 + exit -1
5903 +fi
5904 +
5905 +# check opts
5906 +if ! [ -d "$MNT_DIR" ]; then
5907 + echo "invalid mount dir $MNT_DIR, run $0 -h for help."
5908 + exit -1
5909 +fi
5910 +
5911 +if ! [ -d "$STO_DIR" ]; then
5912 + echo "invalid sto_dir_dir $STO_DIR, run $0 -h for help."
5913 + exit -1
5914 +fi
5915 +
5916 +MNTP="$MNT_DIR/mini_fo-`basename $BASE`$SUFF"
5917 +STO="$STO_DIR/sto-`basename $BASE`$SUFF"
5918 +
5919 +# create the mount point if it doesn't exist
5920 +mkdir -p $MNTP
5921 +if [ $? -ne 0 ]; then
5922 + echo "Error, failed to create mount point $MNTP"
5923 +fi
5924 +
5925 +mkdir -p $STO
5926 +if [ $? -ne 0 ]; then
5927 + echo "Error, failed to create storage dir $STO"
5928 +fi
5929 +
5930 +# check if fs is already mounted
5931 +mount | grep mini_fo | grep $MNTP &> /dev/null
5932 +if [ $? -eq 0 ]; then
5933 + echo "Error, existing mini_fo mount at $MNTP."
5934 + exit -1
5935 +fi
5936 +
5937 +mount | grep mini_fo | grep $STO &> /dev/null
5938 +if [ $? -eq 0 ]; then
5939 + echo "Error, $STO seems to be used already."
5940 + exit -1
5941 +fi
5942 +
5943 +# mount
5944 +mount -t mini_fo -o base=$BASE,sto=$STO $BASE $MNTP
5945 +
5946 +if [ $? -ne 0 ]; then
5947 + echo "Error, mounting failed, maybe no permisson to mount?"
5948 +fi
5949 --- /dev/null
5950 +++ b/fs/mini_fo/mmap.c
5951 @@ -0,0 +1,637 @@
5952 +/*
5953 + * Copyright (c) 1997-2003 Erez Zadok
5954 + * Copyright (c) 2001-2003 Stony Brook University
5955 + *
5956 + * For specific licensing information, see the COPYING file distributed with
5957 + * this package, or get one from ftp://ftp.filesystems.org/pub/fist/COPYING.
5958 + *
5959 + * This Copyright notice must be kept intact and distributed with all
5960 + * fistgen sources INCLUDING sources generated by fistgen.
5961 + */
5962 +/*
5963 + * Copyright (C) 2004, 2005 Markus Klotzbuecher <mk@creamnet.de>
5964 + *
5965 + * This program is free software; you can redistribute it and/or
5966 + * modify it under the terms of the GNU General Public License
5967 + * as published by the Free Software Foundation; either version
5968 + * 2 of the License, or (at your option) any later version.
5969 + */
5970 +
5971 +/*
5972 + * $Id$
5973 + */
5974 +
5975 +#ifdef HAVE_CONFIG_H
5976 +# include <config.h>
5977 +#endif /* HAVE_CONFIG_H */
5978 +
5979 +#include "fist.h"
5980 +#include "mini_fo.h"
5981 +
5982 +
5983 +#ifdef FIST_COUNT_WRITES
5984 +/* for counting writes in the middle vs. regular writes */
5985 +unsigned long count_writes = 0, count_writes_middle = 0;
5986 +#endif /* FIST_COUNT_WRITES */
5987 +
5988 +/* forward declaration of commit write and prepare write */
5989 +STATIC int mini_fo_commit_write(file_t *file, page_t *page, unsigned from, unsigned to);
5990 +STATIC int mini_fo_prepare_write(file_t *file, page_t *page, unsigned from, unsigned to);
5991 +
5992 +
5993 +/*
5994 + * Function for handling creation of holes when lseek-ing past the
5995 + * end of the file and then writing some data.
5996 + */
5997 +int
5998 +mini_fo_fill_zeros(file_t* file, page_t *page, unsigned from)
5999 +{
6000 + int err = 0;
6001 + dentry_t *dentry = file->f_dentry;
6002 + inode_t *inode = dentry->d_inode;
6003 + page_t *tmp_page;
6004 + int index;
6005 +
6006 + print_entry_location();
6007 +
6008 + for (index = inode->i_size >> PAGE_CACHE_SHIFT; index < page->index; index++) {
6009 + tmp_page = mini_fo_get1page(file, index);
6010 + if (IS_ERR(tmp_page)) {
6011 + err = PTR_ERR(tmp_page);
6012 + goto out;
6013 + }
6014 +
6015 + /*
6016 + * zero out rest of the contents of the page between the appropriate
6017 + * offsets.
6018 + */
6019 + memset((char*)page_address(tmp_page) + (inode->i_size & ~PAGE_CACHE_MASK), 0, PAGE_CACHE_SIZE - (inode->i_size & ~PAGE_CACHE_MASK));
6020 +
6021 + if (! (err = mini_fo_prepare_write(file, tmp_page, 0, PAGE_CACHE_SIZE)))
6022 + err = mini_fo_commit_write(file, tmp_page, 0, PAGE_CACHE_SIZE);
6023 +
6024 + page_cache_release(tmp_page);
6025 + if (err < 0)
6026 + goto out;
6027 + if (current->need_resched)
6028 + schedule();
6029 + }
6030 +
6031 + /* zero out appropriate parts of last page */
6032 +
6033 + /*
6034 + * if the encoding type is block, then adjust the 'from' (where the
6035 + * zeroing will start) offset appropriately
6036 + */
6037 + from = from & (~(FIST_ENCODING_BLOCKSIZE - 1));
6038 +
6039 + if ((from - (inode->i_size & ~PAGE_CACHE_MASK)) > 0) {
6040 +
6041 + memset((char*)page_address(page) + (inode->i_size & ~PAGE_CACHE_MASK), 0, from - (inode->i_size & ~PAGE_CACHE_MASK));
6042 + if (! (err = mini_fo_prepare_write(file, page, 0, PAGE_CACHE_SIZE)))
6043 + err = mini_fo_commit_write(file, page, 0, PAGE_CACHE_SIZE);
6044 +
6045 + if (err < 0)
6046 + goto out;
6047 + if (current->need_resched)
6048 + schedule();
6049 + }
6050 +
6051 + out:
6052 + print_exit_status(err);
6053 + return err;
6054 +}
6055 +
6056 +
6057 +
6058 +STATIC int
6059 +mini_fo_writepage(page_t *page)
6060 +{
6061 + int err = -EIO;
6062 + inode_t *inode;
6063 + inode_t *hidden_inode;
6064 + page_t *hidden_page;
6065 + char *kaddr, *hidden_kaddr;
6066 +
6067 + print_entry_location();
6068 +
6069 + inode = page->mapping->host;
6070 + hidden_inode = itohi(inode);
6071 +
6072 + /*
6073 + * writepage is called when shared mmap'ed files need to write
6074 + * their pages, while prepare/commit_write are called from the
6075 + * non-paged write() interface. (However, in 2.3 the two interfaces
6076 + * share the same cache, while in 2.2 they didn't.)
6077 + *
6078 + * So we pretty much have to duplicate much of what commit_write does.
6079 + */
6080 +
6081 + /* find lower page (returns a locked page) */
6082 + hidden_page = grab_cache_page(hidden_inode->i_mapping, page->index);
6083 + if (!hidden_page)
6084 + goto out;
6085 +
6086 + /* get page address, and encode it */
6087 + kaddr = (char *) kmap(page);
6088 + hidden_kaddr = (char*) kmap(hidden_page);
6089 + mini_fo_encode_block(kaddr, hidden_kaddr, PAGE_CACHE_SIZE, inode, inode->i_sb, page->index);
6090 + /* if encode_block could fail, then return error */
6091 + kunmap(page);
6092 + kunmap(hidden_page);
6093 +
6094 + /* call lower writepage (expects locked page) */
6095 + err = hidden_inode->i_mapping->a_ops->writepage(hidden_page);
6096 +
6097 + /*
6098 + * update mtime and ctime of lower level file system
6099 + * mini_fo' mtime and ctime are updated by generic_file_write
6100 + */
6101 + hidden_inode->i_mtime = hidden_inode->i_ctime = CURRENT_TIME;
6102 +
6103 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,1)
6104 + UnlockPage(hidden_page); /* b/c grab_cache_page locked it */
6105 +# endif /* kernel older than 2.4.1 */
6106 + page_cache_release(hidden_page); /* b/c grab_cache_page increased refcnt */
6107 +
6108 + if (err)
6109 + ClearPageUptodate(page);
6110 + else
6111 + SetPageUptodate(page);
6112 + out:
6113 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,1)
6114 + UnlockPage(page);
6115 +# endif /* kernel 2.4.1 and newer */
6116 + print_exit_status(err);
6117 + return err;
6118 +}
6119 +
6120 +
6121 +/*
6122 + * get one page from cache or lower f/s, return error otherwise.
6123 + * returns unlocked, up-to-date page (if ok), with increased refcnt.
6124 + */
6125 +page_t *
6126 +mini_fo_get1page(file_t *file, int index)
6127 +{
6128 + page_t *page;
6129 + dentry_t *dentry;
6130 + inode_t *inode;
6131 + struct address_space *mapping;
6132 + int err;
6133 +
6134 + print_entry_location();
6135 +
6136 + dentry = file->f_dentry; /* CPW: Moved below print_entry_location */
6137 + inode = dentry->d_inode;
6138 + mapping = inode->i_mapping;
6139 +
6140 + fist_dprint(8, "%s: read page index %d pid %d\n", __FUNCTION__, index, current->pid);
6141 + if (index < 0) {
6142 + printk("%s BUG: index=%d\n", __FUNCTION__, index);
6143 + page = ERR_PTR(-EIO);
6144 + goto out;
6145 + }
6146 + page = read_cache_page(mapping,
6147 + index,
6148 + (filler_t *) mapping->a_ops->readpage,
6149 + (void *) file);
6150 + if (IS_ERR(page))
6151 + goto out;
6152 + wait_on_page(page);
6153 + if (!Page_Uptodate(page)) {
6154 + lock_page(page);
6155 + err = mapping->a_ops->readpage(file, page);
6156 + if (err) {
6157 + page = ERR_PTR(err);
6158 + goto out;
6159 + }
6160 + wait_on_page(page);
6161 + if (!Page_Uptodate(page)) {
6162 + page = ERR_PTR(-EIO);
6163 + goto out;
6164 + }
6165 + }
6166 +
6167 + out:
6168 + print_exit_pointer(page);
6169 + return page;
6170 +}
6171 +
6172 +
6173 +/*
6174 + * get one page from cache or lower f/s, return error otherwise.
6175 + * similar to get1page, but doesn't guarantee that it will return
6176 + * an unlocked page.
6177 + */
6178 +page_t *
6179 +mini_fo_get1page_cached(file_t *file, int index)
6180 +{
6181 + page_t *page;
6182 + dentry_t *dentry;
6183 + inode_t *inode;
6184 + struct address_space *mapping;
6185 + int err;
6186 +
6187 + print_entry_location();
6188 +
6189 + dentry = file->f_dentry; /* CPW: Moved below print_entry_location */
6190 + inode = dentry->d_inode;
6191 + mapping = inode->i_mapping;
6192 +
6193 + fist_dprint(8, "%s: read page index %d pid %d\n", __FUNCTION__, index, current->pid);
6194 + if (index < 0) {
6195 + printk("%s BUG: index=%d\n", __FUNCTION__, index);
6196 + page = ERR_PTR(-EIO);
6197 + goto out;
6198 + }
6199 + page = read_cache_page(mapping,
6200 + index,
6201 + (filler_t *) mapping->a_ops->readpage,
6202 + (void *) file);
6203 + if (IS_ERR(page))
6204 + goto out;
6205 +
6206 + out:
6207 + print_exit_pointer(page);
6208 + return page;
6209 +}
6210 +
6211 +
6212 +/*
6213 + * readpage is called from generic_page_read and the fault handler.
6214 + * If your file system uses generic_page_read for the read op, it
6215 + * must implement readpage.
6216 + *
6217 + * Readpage expects a locked page, and must unlock it.
6218 + */
6219 +STATIC int
6220 +mini_fo_do_readpage(file_t *file, page_t *page)
6221 +{
6222 + int err = -EIO;
6223 + dentry_t *dentry;
6224 + file_t *hidden_file = NULL;
6225 + dentry_t *hidden_dentry;
6226 + inode_t *inode;
6227 + inode_t *hidden_inode;
6228 + char *page_data;
6229 + page_t *hidden_page;
6230 + char *hidden_page_data;
6231 + int real_size;
6232 +
6233 + print_entry_location();
6234 +
6235 + dentry = file->f_dentry; /* CPW: Moved below print_entry_location */
6236 + if (ftopd(file) != NULL)
6237 + hidden_file = ftohf(file);
6238 + hidden_dentry = dtohd(dentry);
6239 + inode = dentry->d_inode;
6240 + hidden_inode = itohi(inode);
6241 +
6242 + fist_dprint(7, "%s: requesting page %d from file %s\n", __FUNCTION__, page->index, dentry->d_name.name);
6243 +
6244 + MALLOC_PAGE_POINTERS(hidden_pages, num_hidden_pages);
6245 + MALLOC_PAGEDATA_POINTERS(hidden_pages_data, num_hidden_pages);
6246 + FOR_EACH_PAGE
6247 + CURRENT_HIDDEN_PAGE = NULL;
6248 +
6249 + /* find lower page (returns a locked page) */
6250 + FOR_EACH_PAGE {
6251 + fist_dprint(8, "%s: Current page index = %d\n", __FUNCTION__, CURRENT_HIDDEN_PAGEINDEX);
6252 + CURRENT_HIDDEN_PAGE = read_cache_page(hidden_inode->i_mapping,
6253 + CURRENT_HIDDEN_PAGEINDEX,
6254 + (filler_t *) hidden_inode->i_mapping->a_ops->readpage,
6255 + (void *) hidden_file);
6256 + if (IS_ERR(CURRENT_HIDDEN_PAGE)) {
6257 + err = PTR_ERR(CURRENT_HIDDEN_PAGE);
6258 + CURRENT_HIDDEN_PAGE = NULL;
6259 + goto out_release;
6260 + }
6261 + }
6262 +
6263 + /*
6264 + * wait for the page data to show up
6265 + * (signaled by readpage as unlocking the page)
6266 + */
6267 + FOR_EACH_PAGE {
6268 + wait_on_page(CURRENT_HIDDEN_PAGE);
6269 + if (!Page_Uptodate(CURRENT_HIDDEN_PAGE)) {
6270 + /*
6271 + * call readpage() again if we returned from wait_on_page with a
6272 + * page that's not up-to-date; that can happen when a partial
6273 + * page has a few buffers which are ok, but not the whole
6274 + * page.
6275 + */
6276 + lock_page(CURRENT_HIDDEN_PAGE);
6277 + err = hidden_inode->i_mapping->a_ops->readpage(hidden_file,
6278 + CURRENT_HIDDEN_PAGE);
6279 + if (err) {
6280 + CURRENT_HIDDEN_PAGE = NULL;
6281 + goto out_release;
6282 + }
6283 + wait_on_page(CURRENT_HIDDEN_PAGE);
6284 + if (!Page_Uptodate(CURRENT_HIDDEN_PAGE)) {
6285 + err = -EIO;
6286 + goto out_release;
6287 + }
6288 + }
6289 + }
6290 +
6291 + /* map pages, get their addresses */
6292 + page_data = (char *) kmap(page);
6293 + FOR_EACH_PAGE
6294 + CURRENT_HIDDEN_PAGEDATA = (char *) kmap(CURRENT_HIDDEN_PAGE);
6295 +
6296 + /* if decode_block could fail, then return error */
6297 + err = 0;
6298 + real_size = hidden_inode->i_size - (page->index << PAGE_CACHE_SHIFT);
6299 + if (real_size <= 0)
6300 + memset(page_data, 0, PAGE_CACHE_SIZE);
6301 + else if (real_size < PAGE_CACHE_SIZE) {
6302 + mini_fo_decode_block(hidden_page_data, page_data, real_size, inode, inode->i_sb, page->index);
6303 + memset(page_data + real_size, 0, PAGE_CACHE_SIZE - real_size);
6304 + } else
6305 + mini_fo_decode_block(hidden_page_data, page_data, PAGE_CACHE_SIZE, inode, inode->i_sb, page->index);
6306 +
6307 + FOR_EACH_PAGE
6308 + kunmap(CURRENT_HIDDEN_PAGE);
6309 + kunmap(page);
6310 +
6311 + out_release:
6312 + FOR_EACH_PAGE
6313 + if (CURRENT_HIDDEN_PAGE)
6314 + page_cache_release(CURRENT_HIDDEN_PAGE); /* undo read_cache_page */
6315 +
6316 + FREE_PAGE_POINTERS(hidden_pages, num_hidden_pages);
6317 + FREE_PAGEDATA_POINTERS(hidden_pages_data, num_hidden_pages);
6318 +
6319 + out:
6320 + if (err == 0)
6321 + SetPageUptodate(page);
6322 + else
6323 + ClearPageUptodate(page);
6324 +
6325 + print_exit_status(err);
6326 + return err;
6327 +}
6328 +
6329 +
6330 +STATIC int
6331 +mini_fo_readpage(file_t *file, page_t *page)
6332 +{
6333 + int err;
6334 + print_entry_location();
6335 +
6336 + err = mini_fo_do_readpage(file, page);
6337 +
6338 + /*
6339 + * we have to unlock our page, b/c we _might_ have gotten a locked page.
6340 + * but we no longer have to wakeup on our page here, b/c UnlockPage does
6341 + * it
6342 + */
6343 + UnlockPage(page);
6344 +
6345 + print_exit_status(err);
6346 + return err;
6347 +}
6348 +
6349 +
6350 +STATIC int
6351 +mini_fo_prepare_write(file_t *file, page_t *page, unsigned from, unsigned to)
6352 +{
6353 + int err = 0;
6354 +
6355 + print_entry_location();
6356 +
6357 + /*
6358 + * we call kmap(page) only here, and do the kunmap
6359 + * and the actual downcalls, including unlockpage and uncache
6360 + * in commit_write.
6361 + */
6362 + kmap(page);
6363 +
6364 + /* fast path for whole page writes */
6365 + if (from == 0 && to == PAGE_CACHE_SIZE)
6366 + goto out;
6367 + /* read the page to "revalidate" our data */
6368 + /* call the helper function which doesn't unlock the page */
6369 + if (!Page_Uptodate(page))
6370 + err = mini_fo_do_readpage(file, page);
6371 +
6372 + out:
6373 + print_exit_status(err);
6374 + return err;
6375 +}
6376 +
6377 +
6378 +
6379 +STATIC int
6380 +mini_fo_commit_write(file_t *file, page_t *page, unsigned from, unsigned to)
6381 +{
6382 + int err = -ENOMEM;
6383 + inode_t *inode;
6384 + inode_t *hidden_inode;
6385 + page_t *hidden_page;
6386 + file_t *hidden_file = NULL;
6387 + loff_t pos;
6388 + unsigned bytes = to - from;
6389 + unsigned hidden_from, hidden_to, hidden_bytes;
6390 +
6391 + print_entry_location();
6392 +
6393 + inode = page->mapping->host; /* CPW: Moved below print_entry_location */
6394 + hidden_inode = itohi(inode);
6395 +
6396 + ASSERT(file != NULL);
6397 + /*
6398 + * here we have a kmapped page, with data from the user copied
6399 + * into it. we need to encode_block it, and then call the lower
6400 + * commit_write. We also need to simulate same behavior of
6401 + * generic_file_write, and call prepare_write on the lower f/s first.
6402 + */
6403 +#ifdef FIST_COUNT_WRITES
6404 + count_writes++;
6405 +# endif /* FIST_COUNT_WRITES */
6406 +
6407 + /* this is append and/or extend -- we can't have holes so fill them in */
6408 + if (page->index > (hidden_inode->i_size >> PAGE_CACHE_SHIFT)) {
6409 + page_t *tmp_page;
6410 + int index;
6411 + for (index = hidden_inode->i_size >> PAGE_CACHE_SHIFT; index < page->index; index++) {
6412 + tmp_page = mini_fo_get1page(file, index);
6413 + if (IS_ERR(tmp_page)) {
6414 + err = PTR_ERR(tmp_page);
6415 + goto out;
6416 + }
6417 + /* zero out the contents of the page at the appropriate offsets */
6418 + memset((char*)page_address(tmp_page) + (inode->i_size & ~PAGE_CACHE_MASK), 0, PAGE_CACHE_SIZE - (inode->i_size & ~PAGE_CACHE_MASK));
6419 + if (!(err = mini_fo_prepare_write(file, tmp_page, 0, PAGE_CACHE_SIZE)))
6420 + err = mini_fo_commit_write(file, tmp_page, 0, PAGE_CACHE_SIZE);
6421 + page_cache_release(tmp_page);
6422 + if (err < 0)
6423 + goto out;
6424 + if (current->need_resched)
6425 + schedule();
6426 + }
6427 + }
6428 +
6429 + if (ftopd(file) != NULL)
6430 + hidden_file = ftohf(file);
6431 +
6432 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
6433 + mutex_lock(&hidden_inode->i_mutex);
6434 +#else
6435 + down(&hidden_inode->i_sem);
6436 +#endif
6437 + /* find lower page (returns a locked page) */
6438 + hidden_page = grab_cache_page(hidden_inode->i_mapping, page->index);
6439 + if (!hidden_page)
6440 + goto out;
6441 +
6442 +#if FIST_ENCODING_BLOCKSIZE > 1
6443 +# error encoding_blocksize greater than 1 is not yet supported
6444 +# endif /* FIST_ENCODING_BLOCKSIZE > 1 */
6445 +
6446 + hidden_from = from & (~(FIST_ENCODING_BLOCKSIZE - 1));
6447 + hidden_to = ((to + FIST_ENCODING_BLOCKSIZE - 1) & (~(FIST_ENCODING_BLOCKSIZE - 1)));
6448 + if ((page->index << PAGE_CACHE_SHIFT) + to > hidden_inode->i_size) {
6449 +
6450 + /*
6451 + * if this call to commit_write had introduced holes and the code
6452 + * for handling holes was invoked, then the beginning of this page
6453 + * must be zeroed out
6454 + * zero out bytes from 'size_of_file%pagesize' to 'from'.
6455 + */
6456 + if ((hidden_from - (inode->i_size & ~PAGE_CACHE_MASK)) > 0)
6457 + memset((char*)page_address(page) + (inode->i_size & ~PAGE_CACHE_MASK), 0, hidden_from - (inode->i_size & ~PAGE_CACHE_MASK));
6458 +
6459 + }
6460 + hidden_bytes = hidden_to - hidden_from;
6461 +
6462 + /* call lower prepare_write */
6463 + err = -EINVAL;
6464 + if (hidden_inode->i_mapping &&
6465 + hidden_inode->i_mapping->a_ops &&
6466 + hidden_inode->i_mapping->a_ops->prepare_write)
6467 + err = hidden_inode->i_mapping->a_ops->prepare_write(hidden_file,
6468 + hidden_page,
6469 + hidden_from,
6470 + hidden_to);
6471 + if (err)
6472 + /* don't leave locked pages behind, esp. on an ENOSPC */
6473 + goto out_unlock;
6474 +
6475 + fist_dprint(8, "%s: encoding %d bytes\n", __FUNCTION__, hidden_bytes);
6476 + mini_fo_encode_block((char *) page_address(page) + hidden_from, (char*) page_address(hidden_page) + hidden_from, hidden_bytes, inode, inode->i_sb, page->index);
6477 + /* if encode_block could fail, then goto unlock and return error */
6478 +
6479 + /* call lower commit_write */
6480 + err = hidden_inode->i_mapping->a_ops->commit_write(hidden_file,
6481 + hidden_page,
6482 + hidden_from,
6483 + hidden_to);
6484 +
6485 + if (err < 0)
6486 + goto out_unlock;
6487 +
6488 + err = bytes; /* convert error to no. of bytes */
6489 +
6490 + inode->i_blocks = hidden_inode->i_blocks;
6491 + /* we may have to update i_size */
6492 + pos = (page->index << PAGE_CACHE_SHIFT) + to;
6493 + if (pos > inode->i_size)
6494 + inode->i_size = pos;
6495 +
6496 + /*
6497 + * update mtime and ctime of lower level file system
6498 + * mini_fo' mtime and ctime are updated by generic_file_write
6499 + */
6500 + hidden_inode->i_mtime = hidden_inode->i_ctime = CURRENT_TIME;
6501 +
6502 + mark_inode_dirty_sync(inode);
6503 +
6504 + out_unlock:
6505 + UnlockPage(hidden_page);
6506 + page_cache_release(hidden_page);
6507 + kunmap(page); /* kmap was done in prepare_write */
6508 + out:
6509 + /* we must set our page as up-to-date */
6510 + if (err < 0)
6511 + ClearPageUptodate(page);
6512 + else
6513 + SetPageUptodate(page);
6514 +
6515 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
6516 + mutex_unlock(&hidden_inode->i_mutex);
6517 +#else
6518 + up(&hidden_inode->i_sem);
6519 +#endif
6520 + print_exit_status(err);
6521 + return err; /* assume all is ok */
6522 +}
6523 +
6524 +
6525 +STATIC int
6526 +mini_fo_bmap(struct address_space *mapping, long block)
6527 +{
6528 + int err = 0;
6529 + inode_t *inode;
6530 + inode_t *hidden_inode;
6531 +
6532 + print_entry_location();
6533 +
6534 + inode = (inode_t *) mapping->host;
6535 + hidden_inode = itohi(inode);
6536 +
6537 + if (hidden_inode->i_mapping->a_ops->bmap)
6538 + err = hidden_inode->i_mapping->a_ops->bmap(hidden_inode->i_mapping, block);
6539 + print_exit_location();
6540 + return err;
6541 +}
6542 +
6543 +
6544 +/*
6545 + * This function is copied verbatim from mm/filemap.c.
6546 + * XXX: It should be simply moved to some header file instead -- bug Al about it!
6547 + */
6548 +static inline int sync_page(struct page *page)
6549 +{
6550 + struct address_space *mapping = page->mapping;
6551 +
6552 + if (mapping && mapping->a_ops && mapping->a_ops->sync_page)
6553 + return mapping->a_ops->sync_page(page);
6554 + return 0;
6555 +}
6556 +
6557 +
6558 +/*
6559 + * XXX: we may not need this function if not FIST_FILTER_DATA.
6560 + * FIXME: for FIST_FILTER_SCA, get all lower pages and sync them each.
6561 + */
6562 +STATIC int
6563 +mini_fo_sync_page(page_t *page)
6564 +{
6565 + int err = 0;
6566 + inode_t *inode;
6567 + inode_t *hidden_inode;
6568 + page_t *hidden_page;
6569 +
6570 + print_entry_location();
6571 +
6572 + inode = page->mapping->host; /* CPW: Moved below print_entry_location */
6573 + hidden_inode = itohi(inode);
6574 +
6575 + /* find lower page (returns a locked page) */
6576 + hidden_page = grab_cache_page(hidden_inode->i_mapping, page->index);
6577 + if (!hidden_page)
6578 + goto out;
6579 +
6580 + err = sync_page(hidden_page);
6581 +
6582 + UnlockPage(hidden_page); /* b/c grab_cache_page locked it */
6583 + page_cache_release(hidden_page); /* b/c grab_cache_page increased refcnt */
6584 +
6585 + out:
6586 + print_exit_status(err);
6587 + return err;
6588 +}
6589 --- /dev/null
6590 +++ b/fs/mini_fo/README
6591 @@ -0,0 +1,163 @@
6592 +README for the mini_fo overlay file system
6593 +=========================================
6594 +
6595 +
6596 +WHAT IS MINI_FO?
6597 +----------------
6598 +
6599 +mini_fo is a virtual kernel file system that can make read-only
6600 +file systems writable. This is done by redirecting modifying operations
6601 +to a writeable location called "storage directory", and leaving the
6602 +original data in the "base directory" untouched. When reading, the
6603 +file system merges the modifed and original data so that only the
6604 +newest versions will appear. This occurs transparently to the user,
6605 +who can access the data like on any other read-write file system.
6606 +
6607 +Base and storage directories may be located on the same or on
6608 +different partitions and may be of different file system types. While
6609 +the storage directory obviously needs to be writable, the base may or
6610 +may not be writable, what doesn't matter as it will no be modified
6611 +anyway.
6612 +
6613 +
6614 +WHAT IS GOOD FOR?
6615 +-----------------
6616 +
6617 +The primary purpose of the mini_fo file system is to allow easy
6618 +software updates to embedded systems, that often store their root
6619 +file system in a read-only flash file system, but there are many
6620 +more as for example sandboxing, or for allowing live-cds to
6621 +permanently store information.
6622 +
6623 +
6624 +BUILDING
6625 +--------
6626 +This should be simple. Adjust the Makefile to point to the correct
6627 +kernel headers you want to build the module for. Then:
6628 +
6629 + # make
6630 +
6631 +should build "mini_fo.o" for a 2.4 kernel or "mini_fo.ko" for a 2.6
6632 +kernel.
6633 +
6634 +If you are building the module for you current kernel, you can install
6635 +the module (as root):
6636 +
6637 + # make install
6638 +
6639 +or uninstall with
6640 +
6641 + # make uninstall
6642 +
6643 +
6644 +USING THE FILE SYSTEM
6645 +--------------------
6646 +
6647 +the general mount syntax is:
6648 +
6649 + mount -t mini_fo -o base=<base directory>,sto=<storage directory>\
6650 + <base directory> <mount point>
6651 +
6652 +Example:
6653 +
6654 +You have mounted a cdrom to /mnt/cdrom and want to modifiy some files
6655 +on it:
6656 +
6657 +load the module (as root)
6658 +
6659 + # insmod mini_fo.o for a 2.4 kernel or
6660 +
6661 + # insmod mini_fo.ko for a 2.6 kernel
6662 +
6663 +
6664 +create a storage dir in tmp and a mountpoint for mini_fo:
6665 +
6666 + # mkdir /tmp/sto
6667 + # mkdir /mnt/mini_fo
6668 +
6669 +and mount the mini_fo file system:
6670 +
6671 + # mount -t mini_fo -o base=/mnt/cdrom,sto=/tmp/sto /mnt/cdrom /mnt/mini_fo
6672 +
6673 +
6674 +Now the data stored on the cd can be accessed via the mini_fo
6675 +mountpoint just like any read-write file system, files can be modified
6676 +and deleted, new ones can be created and so on. When done unmount the
6677 +file system:
6678 +
6679 + # unmount /mnt/mini_fo
6680 +
6681 +Note that if the file system is mounted again using the same storage
6682 +file system, of course it will appear in the modified state again. If
6683 +you remount it using an new empty storage directory, it will be
6684 +unmodified. Therefore by executing:
6685 +
6686 + # cd /tmp/sto
6687 + # rm -rf *
6688 +
6689 +you can nuke all the changes you made to the original file system. But
6690 + remember NEVER do this while the mini_fo file system is mounted!
6691 +
6692 +
6693 +Alternatively you can use the mini_fo-overlay bash script, that
6694 +simplifies managing mini_fo mounts. See TOOLS Section.
6695 +
6696 +
6697 +TOOLS
6698 +-----
6699 +
6700 +mini_fo-merge (experimental):
6701 +
6702 +This is a bash script that will merge changes contained in the storage
6703 +directory back to the base directory. This allows mini_fo to function
6704 +as a cache file system by overlaying a slow (network, ...) file system
6705 +and using a fast (ramdisk, ...) as storage. When done, changes can be
6706 +merged back to the (slow) base with mini_fo-merge. See "mini_fo-merge
6707 +-h" for details.
6708 +
6709 +It can be usefull for merging changes back after a successfull test
6710 +(patches, software updates...)
6711 +
6712 +
6713 +mini_fo-overlay:
6714 +
6715 +This bash script simplifies managing one or more mini_fo mounts. For
6716 +overlaying a directory called "basedir1", you can just call:
6717 +
6718 + # mini_fo-overlay basedir1
6719 +
6720 +This will mount mini_fo with "basedir1" as base, "/tmp/sto-basedir1/"
6721 +as storage to "/mnt/mini_fo-basedir1/". It has more options though,
6722 +type "mini_fo-overlay -h" for details.
6723 +
6724 +
6725 +DOCUMENTATION, REPORTING BUGS, GETTING HELP
6726 +-------------------------------------------
6727 +
6728 +Please visit the mini_fo project page at:
6729 +
6730 +http://www.denx.de/twiki/bin/view/Know/MiniFOHome
6731 +
6732 +
6733 +WARNINGS
6734 +--------
6735 +
6736 +Never modify the base or the storage directorys while the mini_fo
6737 +file system is mounted, or you might crash you system. Simply accessing
6738 +and reading should not cause any trouble.
6739 +
6740 +Exporting a mini_fo mount point via NFS has not been tested, and may
6741 +or may not work.
6742 +
6743 +Check the RELEASE_NOTES for details on bugs and features.
6744 +
6745 +
6746 +
6747 +Copyright (C) 2004, 2005 Markus Klotzbuecher <mk@creamnet.de>
6748 +
6749 +This program is free software; you can redistribute it and/or
6750 +modify it under the terms of the GNU General Public License
6751 +as published by the Free Software Foundation; either version
6752 +2 of the License, or (at your option) any later version.
6753 +
6754 +
6755 --- /dev/null
6756 +++ b/fs/mini_fo/RELEASE_NOTES
6757 @@ -0,0 +1,111 @@
6758 +Release: mini_fo-0.6.1 (v0-6-1)
6759 +Date: 21.09.2005
6760 +
6761 +
6762 +Changes:
6763 +--------
6764 +v0-6-1:
6765 +
6766 +- bugfixes (see ChangeLog)
6767 +
6768 +- two helper scripts "mini_fo_merge" and "mini_fo_overlay" (see
6769 + README for details).
6770 +
6771 +v0-6-0:
6772 +
6773 +- Support for 2.4 and 2.6 (see Makefile)
6774 +
6775 +- Partial hard link support (creating works as expected, but already
6776 + existing links in the base file system will be treated as if they
6777 + were individual files).
6778 +
6779 +- Various bugfixes and cleanups.
6780 +
6781 +
6782 +v0-6-0-pre1:
6783 +
6784 +- This is mini_fo-0-6-0-pre1! This release is a complete rewrite of
6785 + many vital mini_fo parts such as the old whiteout list code which
6786 + has been replaced by the new META subsystem.
6787 +
6788 +- Light weight directory renaming implemented. This means if a
6789 + directory is renamed via the mini_fo filesystem this will no longer
6790 + result in a complete copy in storage, instead only one empty
6791 + directory will be created. All base filed contained in the original
6792 + directory stay there until modified.
6793 +
6794 +- Special files (creating, renaming, deleting etc.) now working.
6795 +
6796 +- Many bugfixes and cleanup, mini_fo is now a lot more stable.
6797 +
6798 +
6799 +v0-5-10:
6800 +
6801 +- Final release of the 0-5-* versions. Next will be a complete rewrite
6802 + of many features. This release contains several bugfixes related to
6803 + directory renaming.
6804 +
6805 +
6806 +v0-5-10-pre6:
6807 +
6808 +- Lots of cleanup and several bugfixes related to directory deleting
6809 +
6810 +- Directory renaming suddenly works, what is most likely due to the
6811 + fact tha that "mv" is smart: if the classic rename doesn't work it
6812 + will assume that source and target file are on different fs and will
6813 + copy the directory and try to remove the source directory. Until
6814 + directory removing wasn't implemented, it would fail to do this and
6815 + rollback.
6816 + So, directory renaming works for now, but it doesn't yet do what you
6817 + would expect from a overlay fs, so use with care.
6818 +
6819 +
6820 +v0-5-10-pre5:
6821 +
6822 +- implemented directory deleting
6823 +- made parsing of mount options more stable
6824 +- New format of mount options! (See README)
6825 +- I can't reproduce the unknown panic with 2.4.25 anymore, so I'll
6826 + happily assume it never existed!
6827 +
6828 +
6829 +Implemented features:
6830 +---------------------
6831 +
6832 +- creating hard links (see BUGS on already existing hard links)
6833 +- lightweight directory renaming
6834 +- renaming device files, pipes, sockets, etc.
6835 +- creating, renaming, deleting of special files
6836 +- deleting directorys
6837 +- general directory reading (simple "ls" )
6838 +- creating files in existing directorys
6839 +- creating directorys
6840 +- renaming files.
6841 +- reading and writing files (involves opening)
6842 +- appending to files (creates copy in storage)
6843 +- deleting files
6844 +- llseek works too, what allows editors to work
6845 +- persistency (a deleted file stay deleted over remounts)
6846 +- use of symbolic links
6847 +- creating of device files
6848 +
6849 +
6850 +Not (yet) implemented features:
6851 +-------------------------------
6852 +
6853 +- full hard link support.
6854 +
6855 +
6856 +
6857 +BUGS:
6858 +-----
6859 +
6860 +Hard links in the base file system will be treated as individual
6861 +files, not as links to one inode.
6862 +
6863 +The main problem with hard links isn't allowing to create them, but
6864 +their pure existence. If you modify a base hard link, the changes made
6865 +will only show up on this link, the other link will remain in the
6866 +original state. I hope to fix this someday. Please note that this does
6867 +not effect the special hard links '.' and '..', that are handled
6868 +seperately by the lower fs.
6869 --- /dev/null
6870 +++ b/fs/mini_fo/state.c
6871 @@ -0,0 +1,620 @@
6872 +/*
6873 + * Copyright (C) 2005 Markus Klotzbuecher <mk@creamnet.de>
6874 + *
6875 + * This program is free software; you can redistribute it and/or
6876 + * modify it under the terms of the GNU General Public License
6877 + * as published by the Free Software Foundation; either version
6878 + * 2 of the License, or (at your option) any later version.
6879 + */
6880 +
6881 +#ifdef HAVE_CONFIG_H
6882 +# include <config.h>
6883 +#endif /* HAVE_CONFIG_H */
6884 +
6885 +#include "fist.h"
6886 +#include "mini_fo.h"
6887 +
6888 +
6889 +/* create the storage file, setup new states */
6890 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
6891 +int create_sto_reg_file(dentry_t *dentry, int mode, struct nameidata *nd)
6892 +#else
6893 +int create_sto_reg_file(dentry_t *dentry, int mode)
6894 +#endif
6895 +{
6896 + int err = 0;
6897 + inode_t *dir;
6898 + dentry_t *hidden_sto_dentry;
6899 + dentry_t *hidden_sto_dir_dentry;
6900 +
6901 + if(exists_in_storage(dentry)) {
6902 + printk(KERN_CRIT "mini_fo: create_sto_file: wrong type or state.\n");
6903 + err = -EINVAL;
6904 + goto out;
6905 + }
6906 + err = get_neg_sto_dentry(dentry);
6907 +
6908 + if (err) {
6909 + printk(KERN_CRIT "mini_fo: create_sto_file: ERROR getting neg. sto dentry.\n");
6910 + goto out;
6911 + }
6912 +
6913 + dir = dentry->d_parent->d_inode;
6914 + hidden_sto_dentry = dtohd2(dentry);
6915 +
6916 + /* lock parent */
6917 + hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
6918 +
6919 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
6920 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
6921 +#else
6922 + down(&hidden_sto_dir_dentry->d_inode->i_sem);
6923 +#endif
6924 +
6925 + err = PTR_ERR(hidden_sto_dir_dentry);
6926 + if (IS_ERR(hidden_sto_dir_dentry))
6927 + goto out;
6928 +
6929 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
6930 + err = vfs_create(hidden_sto_dir_dentry->d_inode,
6931 + hidden_sto_dentry,
6932 + mode, nd);
6933 +#else
6934 + err = vfs_create(hidden_sto_dir_dentry->d_inode,
6935 + hidden_sto_dentry,
6936 + mode);
6937 +#endif
6938 + if(err) {
6939 + printk(KERN_CRIT "mini_fo: create_sto_file: ERROR creating sto file.\n");
6940 + goto out_lock;
6941 + }
6942 +
6943 + if(!dtohd2(dentry)->d_inode) {
6944 + printk(KERN_CRIT "mini_fo: create_sto_file: ERROR creating sto file [2].\n");
6945 + err = -EINVAL;
6946 + goto out_lock;
6947 + }
6948 +
6949 + /* interpose the new inode */
6950 + if(dtost(dentry) == DELETED) {
6951 + dtost(dentry) = DEL_REWRITTEN;
6952 + err = mini_fo_tri_interpose(NULL, hidden_sto_dentry, dentry, dir->i_sb, 0);
6953 + if(err)
6954 + goto out_lock;
6955 + }
6956 + else if(dtost(dentry) == NON_EXISTANT) {
6957 + dtost(dentry) = CREATED;
6958 + err = mini_fo_tri_interpose(dtohd(dentry), hidden_sto_dentry, dentry, dir->i_sb, 0);
6959 + if(err)
6960 + goto out_lock;
6961 + }
6962 + else if(dtost(dentry) == UNMODIFIED) {
6963 + dtost(dentry) = MODIFIED;
6964 + /* interpose on new inode */
6965 + if(itohi2(dentry->d_inode) != NULL) {
6966 + printk(KERN_CRIT "mini_fo: create_sto_file: invalid inode detected.\n");
6967 + err = -EINVAL;
6968 + goto out_lock;
6969 + }
6970 + itohi2(dentry->d_inode) = igrab(dtohd2(dentry)->d_inode);
6971 + }
6972 + fist_copy_attr_timesizes(dentry->d_parent->d_inode,
6973 + hidden_sto_dir_dentry->d_inode);
6974 +
6975 + out_lock:
6976 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
6977 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
6978 +#else
6979 + up(&hidden_sto_dir_dentry->d_inode->i_sem);
6980 +#endif
6981 + dput(hidden_sto_dir_dentry);
6982 + out:
6983 + return err;
6984 +}
6985 +
6986 +/* create the sto dir, setup states */
6987 +int create_sto_dir(dentry_t *dentry, int mode)
6988 +{
6989 + int err = 0;
6990 + inode_t *dir;
6991 + dentry_t *hidden_sto_dentry;
6992 + dentry_t *hidden_sto_dir_dentry;
6993 +
6994 + /* had to take the "!S_ISDIR(mode))" check out, because it failed */
6995 + if(exists_in_storage(dentry)) {
6996 + printk(KERN_CRIT "mini_fo: create_sto_dir: wrong type or state.\\
6997 +n");
6998 + err = -EINVAL;
6999 + goto out;
7000 + }
7001 +
7002 + err = get_neg_sto_dentry(dentry);
7003 + if(err) {
7004 + err = -EINVAL;
7005 + goto out;
7006 + }
7007 +
7008 + dir = dentry->d_parent->d_inode;
7009 + hidden_sto_dentry = dtohd2(dentry);
7010 +
7011 + /* was: hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry); */
7012 + hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
7013 +
7014 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
7015 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
7016 +#else
7017 + down(&hidden_sto_dir_dentry->d_inode->i_sem);
7018 +#endif
7019 +
7020 + err = PTR_ERR(hidden_sto_dir_dentry);
7021 + if (IS_ERR(hidden_sto_dir_dentry))
7022 + goto out;
7023 +
7024 + err = vfs_mkdir(hidden_sto_dir_dentry->d_inode,
7025 + hidden_sto_dentry,
7026 + mode);
7027 + if(err) {
7028 + printk(KERN_CRIT "mini_fo: create_sto_dir: ERROR creating sto dir.\n");
7029 + goto out_lock;
7030 + }
7031 +
7032 + if(!dtohd2(dentry)->d_inode) {
7033 + printk(KERN_CRIT "mini_fo: create_sto_dir: ERROR creating sto dir [2].\n");
7034 + err = -EINVAL;
7035 + goto out_lock;
7036 + }
7037 +
7038 + /* interpose the new inode */
7039 + if(dtost(dentry) == DELETED) {
7040 + dtost(dentry) = DEL_REWRITTEN;
7041 + err = mini_fo_tri_interpose(NULL, hidden_sto_dentry, dentry, dir->i_sb, 0);
7042 + if(err)
7043 + goto out_lock;
7044 + }
7045 + else if(dtopd(dentry)->state == NON_EXISTANT) {
7046 + dtopd(dentry)->state = CREATED;
7047 + err = mini_fo_tri_interpose(dtohd(dentry), hidden_sto_dentry, dentry, dir->i_sb, 0);
7048 + if(err)
7049 + goto out_lock;
7050 + }
7051 + else if(dtopd(dentry)->state == UNMODIFIED) {
7052 + dtopd(dentry)->state = MODIFIED;
7053 + /* interpose on new inode */
7054 + if(itohi2(dentry->d_inode) != NULL) {
7055 + printk(KERN_CRIT "mini_fo: create_sto_dir: ERROR, invalid inode detected.\n");
7056 + err = -EINVAL;
7057 + goto out_lock;
7058 + }
7059 + itohi2(dentry->d_inode) = igrab(dtohd2(dentry)->d_inode);
7060 + }
7061 +
7062 + fist_copy_attr_timesizes(dir, hidden_sto_dir_dentry->d_inode);
7063 +
7064 + /* initalize the wol list */
7065 + itopd(dentry->d_inode)->deleted_list_size = -1;
7066 + itopd(dentry->d_inode)->renamed_list_size = -1;
7067 + meta_build_lists(dentry);
7068 +
7069 +
7070 + out_lock:
7071 + /* was: unlock_dir(hidden_sto_dir_dentry); */
7072 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
7073 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
7074 +#else
7075 + up(&hidden_sto_dir_dentry->d_inode->i_sem);
7076 +#endif
7077 + dput(hidden_sto_dir_dentry);
7078 + out:
7079 + return err;
7080 +}
7081 +
7082 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
7083 +int create_sto_nod(dentry_t *dentry, int mode, dev_t dev)
7084 +#else
7085 +int create_sto_nod(dentry_t *dentry, int mode, int dev)
7086 +#endif
7087 +{
7088 + int err = 0;
7089 + inode_t *dir;
7090 + dentry_t *hidden_sto_dentry;
7091 + dentry_t *hidden_sto_dir_dentry;
7092 +
7093 + if(exists_in_storage(dentry)) {
7094 + err = -EEXIST;
7095 + goto out;
7096 + }
7097 + err = get_neg_sto_dentry(dentry);
7098 +
7099 + if (err) {
7100 + printk(KERN_CRIT "mini_fo: create_sto_nod: ERROR getting neg. sto dentry.\n");
7101 + goto out;
7102 + }
7103 +
7104 + dir = dentry->d_parent->d_inode;
7105 + hidden_sto_dentry = dtohd2(dentry);
7106 +
7107 + /* lock parent */
7108 + hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
7109 +
7110 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
7111 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
7112 +#else
7113 + down(&hidden_sto_dir_dentry->d_inode->i_sem);
7114 +#endif
7115 +
7116 + err = PTR_ERR(hidden_sto_dir_dentry);
7117 + if (IS_ERR(hidden_sto_dir_dentry))
7118 + goto out;
7119 +
7120 + err = vfs_mknod(hidden_sto_dir_dentry->d_inode, hidden_sto_dentry, mode, dev);
7121 + if(err)
7122 + goto out_lock;
7123 +
7124 + if(!dtohd2(dentry)->d_inode) {
7125 + printk(KERN_CRIT "mini_fo: create_sto_nod: creating storage inode failed [1].\n");
7126 + err = -EINVAL; /* return something indicating failure */
7127 + goto out_lock;
7128 + }
7129 +
7130 + /* interpose the new inode */
7131 + if(dtost(dentry) == DELETED) {
7132 + dtost(dentry) = DEL_REWRITTEN;
7133 + err = mini_fo_tri_interpose(NULL, hidden_sto_dentry, dentry, dir->i_sb, 0);
7134 + if(err)
7135 + goto out_lock;
7136 + }
7137 + else if(dtost(dentry) == NON_EXISTANT) {
7138 + dtost(dentry) = CREATED;
7139 + err = mini_fo_tri_interpose(dtohd(dentry), hidden_sto_dentry, dentry, dir->i_sb, 0);
7140 + if(err)
7141 + goto out_lock;
7142 + }
7143 + else if(dtost(dentry) == UNMODIFIED) {
7144 + dtost(dentry) = MODIFIED;
7145 + /* interpose on new inode */
7146 + if(itohi2(dentry->d_inode) != NULL) {
7147 + printk(KERN_CRIT "mini_fo: create_sto_nod: error, invalid inode detected.\n");
7148 + err = -EINVAL;
7149 + goto out_lock;
7150 + }
7151 + itohi2(dentry->d_inode) = igrab(dtohd2(dentry)->d_inode);
7152 + }
7153 +
7154 + fist_copy_attr_timesizes(dir, hidden_sto_dir_dentry->d_inode);
7155 +
7156 + out_lock:
7157 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
7158 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
7159 +#else
7160 + up(&hidden_sto_dir_dentry->d_inode->i_sem);
7161 +#endif
7162 + dput(hidden_sto_dir_dentry);
7163 + out:
7164 + return err;
7165 +}
7166 +
7167 +
7168 +/* unimplemented (and possibly not usefull):
7169 +
7170 + nondir-del_to_del_rew
7171 + nondir-non_exist_to_creat
7172 +
7173 + dir-unmod_to_del
7174 + dir-mod_to_del
7175 + dir-creat_to_del
7176 + dir-del_rew_to_del
7177 + dir-del_to_del_rew
7178 + dir-non_exist_to_creat
7179 +*/
7180 +
7181 +
7182 +/* bring a file of any type from state UNMODIFIED to MODIFIED */
7183 +int nondir_unmod_to_mod(dentry_t *dentry, int cp_flag)
7184 +{
7185 + int err = 0;
7186 + struct vfsmount *tgt_mnt;
7187 + struct vfsmount *src_mnt;
7188 + dentry_t *tgt_dentry;
7189 + dentry_t *src_dentry;
7190 + dentry_t *hidden_sto_dentry;
7191 + dentry_t *hidden_sto_dir_dentry;
7192 +
7193 + check_mini_fo_dentry(dentry);
7194 +
7195 + if((dtost(dentry) != UNMODIFIED) ||
7196 + S_ISDIR(dentry->d_inode->i_mode)) {
7197 + printk(KERN_CRIT "mini_fo: nondir_unmod_to_mod: \
7198 + wrong type or state.\n");
7199 + err = -1;
7200 + goto out;
7201 + }
7202 + err = get_neg_sto_dentry(dentry);
7203 +
7204 + if (err) {
7205 + printk(KERN_CRIT "mini_fo: nondir_unmod_to_mod: \
7206 + ERROR getting neg. sto dentry.\n");
7207 + goto out;
7208 + }
7209 +
7210 + /* create sto file */
7211 + hidden_sto_dentry = dtohd2(dentry);
7212 +
7213 + /* lock parent */
7214 + hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
7215 +
7216 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
7217 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
7218 +#else
7219 + down(&hidden_sto_dir_dentry->d_inode->i_sem);
7220 +#endif
7221 +
7222 + err = PTR_ERR(hidden_sto_dir_dentry);
7223 + if (IS_ERR(hidden_sto_dir_dentry))
7224 + goto out;
7225 +
7226 + /* handle different types of nondirs */
7227 + if(S_ISCHR(dentry->d_inode->i_mode) ||
7228 + S_ISBLK(dentry->d_inode->i_mode)) {
7229 + err = vfs_mknod(hidden_sto_dir_dentry->d_inode,
7230 + hidden_sto_dentry,
7231 + dtohd(dentry)->d_inode->i_mode,
7232 + dtohd(dentry)->d_inode->i_rdev);
7233 + }
7234 +
7235 + else if(S_ISREG(dentry->d_inode->i_mode)) {
7236 +
7237 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
7238 + err = vfs_create(hidden_sto_dir_dentry->d_inode,
7239 + hidden_sto_dentry,
7240 + dtohd(dentry)->d_inode->i_mode, NULL);
7241 +#else
7242 + err = vfs_create(hidden_sto_dir_dentry->d_inode,
7243 + hidden_sto_dentry,
7244 + dtohd(dentry)->d_inode->i_mode);
7245 +#endif
7246 + }
7247 + if(err) {
7248 + printk(KERN_CRIT "mini_fo: nondir_unmod_to_mod: \
7249 + ERROR creating sto file.\n");
7250 + goto out_lock;
7251 + }
7252 +
7253 + /* interpose on new inode */
7254 + if(itohi2(dentry->d_inode) != NULL) {
7255 + printk(KERN_CRIT "mini_fo: nondir_unmod_to_mod: \
7256 + ERROR, invalid inode detected.\n");
7257 + err = -EINVAL;
7258 + goto out_lock;
7259 + }
7260 +
7261 + itohi2(dentry->d_inode) = igrab(dtohd2(dentry)->d_inode);
7262 +
7263 + fist_copy_attr_timesizes(dentry->d_parent->d_inode,
7264 + hidden_sto_dir_dentry->d_inode);
7265 + dtost(dentry) = MODIFIED;
7266 +
7267 + /* copy contents if regular file and cp_flag = 1 */
7268 + if((cp_flag == 1) && S_ISREG(dentry->d_inode->i_mode)) {
7269 +
7270 + /* unlock first */
7271 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
7272 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
7273 +#else
7274 + up(&hidden_sto_dir_dentry->d_inode->i_sem);
7275 +#endif
7276 +
7277 + dput(hidden_sto_dir_dentry);
7278 +
7279 + tgt_dentry = dtohd2(dentry);
7280 + tgt_mnt = stopd(dentry->d_inode->i_sb)->hidden_mnt2;
7281 + src_dentry = dtohd(dentry);
7282 + src_mnt = stopd(dentry->d_inode->i_sb)->hidden_mnt;
7283 +
7284 + err = mini_fo_cp_cont(tgt_dentry, tgt_mnt,
7285 + src_dentry, src_mnt);
7286 + if(err) {
7287 + printk(KERN_CRIT "mini_fo: nondir_unmod_to_mod: \
7288 + ERROR copying contents.\n");
7289 + }
7290 + goto out;
7291 + }
7292 +
7293 + out_lock:
7294 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
7295 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
7296 +#else
7297 + up(&hidden_sto_dir_dentry->d_inode->i_sem);
7298 +#endif
7299 + dput(hidden_sto_dir_dentry);
7300 + out:
7301 + return err;
7302 +}
7303 +
7304 +/* this function is currently identical to nondir_creat_to_del */
7305 +int nondir_del_rew_to_del(dentry_t *dentry)
7306 +{
7307 + return nondir_creat_to_del(dentry);
7308 +}
7309 +
7310 +int nondir_creat_to_del(dentry_t *dentry)
7311 +{
7312 + int err = 0;
7313 +
7314 + inode_t *hidden_sto_dir_inode;
7315 + dentry_t *hidden_sto_dir_dentry;
7316 + dentry_t *hidden_sto_dentry;
7317 +
7318 + check_mini_fo_dentry(dentry);
7319 +
7320 + /* for now this function serves for both state DEL_REWRITTEN and
7321 + * CREATED */
7322 + if(!(dtost(dentry) == CREATED || (dtost(dentry) == DEL_REWRITTEN)) ||
7323 + S_ISDIR(dentry->d_inode->i_mode)) {
7324 + printk(KERN_CRIT "mini_fo: nondir_mod_to_del/del_rew_to_del: \
7325 + wrong type or state.\n");
7326 + err = -1;
7327 + goto out;
7328 + }
7329 +
7330 + hidden_sto_dir_inode = itohi2(dentry->d_parent->d_inode);
7331 + hidden_sto_dentry = dtohd2(dentry);
7332 +
7333 + /* was: hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry);*/
7334 + hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
7335 +
7336 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
7337 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
7338 +#else
7339 + down(&hidden_sto_dir_dentry->d_inode->i_sem);
7340 +#endif
7341 +
7342 + /* avoid destroying the hidden inode if the file is in use */
7343 + dget(hidden_sto_dentry);
7344 + err = vfs_unlink(hidden_sto_dir_inode, hidden_sto_dentry);
7345 + dput(hidden_sto_dentry);
7346 + if(!err)
7347 + d_delete(hidden_sto_dentry);
7348 +
7349 + /* propagate number of hard-links */
7350 + dentry->d_inode->i_nlink = itohi2(dentry->d_inode)->i_nlink;
7351 +
7352 + dtost(dentry) = NON_EXISTANT;
7353 +
7354 + /* was: unlock_dir(hidden_sto_dir_dentry); */
7355 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
7356 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
7357 +#else
7358 + up(&hidden_sto_dir_dentry->d_inode->i_sem);
7359 +#endif
7360 + dput(hidden_sto_dir_dentry);
7361 +
7362 + out:
7363 + return err;
7364 +}
7365 +
7366 +int nondir_mod_to_del(dentry_t *dentry)
7367 +{
7368 + int err;
7369 + dentry_t *hidden_sto_dentry;
7370 + inode_t *hidden_sto_dir_inode;
7371 + dentry_t *hidden_sto_dir_dentry;
7372 +
7373 + check_mini_fo_dentry(dentry);
7374 +
7375 + if(dtost(dentry) != MODIFIED ||
7376 + S_ISDIR(dentry->d_inode->i_mode)) {
7377 + printk(KERN_CRIT "mini_fo: nondir_mod_to_del: \
7378 + wrong type or state.\n");
7379 + err = -1;
7380 + goto out;
7381 + }
7382 +
7383 + hidden_sto_dir_inode = itohi2(dentry->d_parent->d_inode);
7384 + hidden_sto_dentry = dtohd2(dentry);
7385 +
7386 + /* was hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry); */
7387 + hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
7388 +
7389 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
7390 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
7391 +#else
7392 + down(&hidden_sto_dir_dentry->d_inode->i_sem);
7393 +#endif
7394 +
7395 + /* avoid destroying the hidden inode if the file is in use */
7396 + dget(hidden_sto_dentry);
7397 + err = vfs_unlink(hidden_sto_dir_inode, hidden_sto_dentry);
7398 + dput(hidden_sto_dentry);
7399 + if(!err)
7400 + d_delete(hidden_sto_dentry);
7401 +
7402 + /* propagate number of hard-links */
7403 + dentry->d_inode->i_nlink = itohi2(dentry->d_inode)->i_nlink;
7404 +
7405 + /* dput base dentry, this will relase the inode and free the
7406 + * dentry, as we will never need it again. */
7407 + dput(dtohd(dentry));
7408 + dtohd(dentry) = NULL;
7409 + dtost(dentry) = DELETED;
7410 +
7411 + /* add deleted file to META-file */
7412 + meta_add_d_entry(dentry->d_parent,
7413 + dentry->d_name.name,
7414 + dentry->d_name.len);
7415 +
7416 + /* was: unlock_dir(hidden_sto_dir_dentry); */
7417 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
7418 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
7419 +#else
7420 + up(&hidden_sto_dir_dentry->d_inode->i_sem);
7421 +#endif
7422 + dput(hidden_sto_dir_dentry);
7423 +
7424 + out:
7425 + return err;
7426 +}
7427 +
7428 +int nondir_unmod_to_del(dentry_t *dentry)
7429 +{
7430 + int err = 0;
7431 +
7432 + check_mini_fo_dentry(dentry);
7433 +
7434 + if(dtost(dentry) != UNMODIFIED ||
7435 + S_ISDIR(dentry->d_inode->i_mode)) {
7436 + printk(KERN_CRIT "mini_fo: nondir_unmod_to_del: \
7437 + wrong type or state.\n");
7438 + err = -1;
7439 + goto out;
7440 + }
7441 +
7442 + /* next we have to get a negative dentry for the storage file */
7443 + err = get_neg_sto_dentry(dentry);
7444 +
7445 + if(err)
7446 + goto out;
7447 +
7448 + /* add deleted file to META lists */
7449 + err = meta_add_d_entry(dentry->d_parent,
7450 + dentry->d_name.name,
7451 + dentry->d_name.len);
7452 +
7453 + if(err)
7454 + goto out;
7455 +
7456 + /* dput base dentry, this will relase the inode and free the
7457 + * dentry, as we will never need it again. */
7458 + dput(dtohd(dentry));
7459 + dtohd(dentry) = NULL;
7460 + dtost(dentry) = DELETED;
7461 +
7462 + out:
7463 + return err;
7464 +}
7465 +
7466 +/* bring a dir from state UNMODIFIED to MODIFIED */
7467 +int dir_unmod_to_mod(dentry_t *dentry)
7468 +{
7469 + int err;
7470 +
7471 + check_mini_fo_dentry(dentry);
7472 +
7473 + if(dtost(dentry) != UNMODIFIED ||
7474 + !S_ISDIR(dentry->d_inode->i_mode)) {
7475 + printk(KERN_CRIT "mini_fo: dir_unmod_to_mod: \
7476 + wrong type or state.\n");
7477 + err = -1;
7478 + goto out;
7479 + }
7480 +
7481 + /* this creates our dir incl. sto. structure */
7482 + err = build_sto_structure(dentry->d_parent, dentry);
7483 + if(err) {
7484 + printk(KERN_CRIT "mini_fo: dir_unmod_to_mod: \
7485 + build_sto_structure failed.\n");
7486 + goto out;
7487 + }
7488 + out:
7489 + return err;
7490 +}
7491 +
7492 --- /dev/null
7493 +++ b/fs/mini_fo/super.c
7494 @@ -0,0 +1,259 @@
7495 +/*
7496 + * Copyright (c) 1997-2003 Erez Zadok
7497 + * Copyright (c) 2001-2003 Stony Brook University
7498 + *
7499 + * For specific licensing information, see the COPYING file distributed with
7500 + * this package, or get one from ftp://ftp.filesystems.org/pub/fist/COPYING.
7501 + *
7502 + * This Copyright notice must be kept intact and distributed with all
7503 + * fistgen sources INCLUDING sources generated by fistgen.
7504 + */
7505 +/*
7506 + * Copyright (C) 2004, 2005 Markus Klotzbuecher <mk@creamnet.de>
7507 + *
7508 + * This program is free software; you can redistribute it and/or
7509 + * modify it under the terms of the GNU General Public License
7510 + * as published by the Free Software Foundation; either version
7511 + * 2 of the License, or (at your option) any later version.
7512 + */
7513 +
7514 +/*
7515 + * $Id$
7516 + */
7517 +
7518 +#ifdef HAVE_CONFIG_H
7519 +# include <config.h>
7520 +#endif
7521 +
7522 +#include "fist.h"
7523 +#include "mini_fo.h"
7524 +
7525 +
7526 +STATIC void
7527 +mini_fo_read_inode(inode_t *inode)
7528 +{
7529 + static struct address_space_operations mini_fo_empty_aops;
7530 +
7531 + __itopd(inode) = kmalloc(sizeof(struct mini_fo_inode_info), GFP_KERNEL);
7532 + if (!itopd(inode)) {
7533 + printk("<0>%s:%s:%d: No kernel memory!\n", __FILE__, __FUNCTION__, __LINE__);
7534 + ASSERT(NULL);
7535 + }
7536 + itohi(inode) = NULL;
7537 + itohi2(inode) = NULL;
7538 +
7539 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
7540 + inode->i_version++;
7541 +#else
7542 + inode->i_version = ++event; /* increment inode version */
7543 +#endif
7544 + inode->i_op = &mini_fo_main_iops;
7545 + inode->i_fop = &mini_fo_main_fops;
7546 +#if 0
7547 + /*
7548 + * XXX: To export a file system via NFS, it has to have the
7549 + * FS_REQUIRES_DEV flag, so turn it on. But should we inherit it from
7550 + * the lower file system, or can we allow our file system to be exported
7551 + * even if the lower one cannot be natively exported.
7552 + */
7553 + inode->i_sb->s_type->fs_flags |= FS_REQUIRES_DEV;
7554 + /*
7555 + * OK, the above was a hack, which is now turned off because it may
7556 + * cause a panic/oops on some systems. The correct way to export a
7557 + * "nodev" filesystem is via using nfs-utils > 1.0 and the "fsid=" export
7558 + * parameter, which requires 2.4.20 or later.
7559 + */
7560 +#endif
7561 + /* I don't think ->a_ops is ever allowed to be NULL */
7562 + inode->i_mapping->a_ops = &mini_fo_empty_aops;
7563 +}
7564 +
7565 +
7566 +#if defined(FIST_DEBUG) || defined(FIST_FILTER_SCA)
7567 +/*
7568 + * No need to call write_inode() on the lower inode, as it
7569 + * will have been marked 'dirty' anyway. But we might need
7570 + * to write some of our own stuff to disk.
7571 + */
7572 +STATIC void
7573 +mini_fo_write_inode(inode_t *inode, int sync)
7574 +{
7575 + print_entry_location();
7576 + print_exit_location();
7577 +}
7578 +#endif /* defined(FIST_DEBUG) || defined(FIST_FILTER_SCA) */
7579 +
7580 +
7581 +STATIC void
7582 +mini_fo_put_inode(inode_t *inode)
7583 +{
7584 + /*
7585 + * This is really funky stuff:
7586 + * Basically, if i_count == 1, iput will then decrement it and this inode will be destroyed.
7587 + * It is currently holding a reference to the hidden inode.
7588 + * Therefore, it needs to release that reference by calling iput on the hidden inode.
7589 + * iput() _will_ do it for us (by calling our clear_inode), but _only_ if i_nlink == 0.
7590 + * The problem is, NFS keeps i_nlink == 1 for silly_rename'd files.
7591 + * So we must for our i_nlink to 0 here to trick iput() into calling our clear_inode.
7592 + */
7593 + if (atomic_read(&inode->i_count) == 1)
7594 + inode->i_nlink = 0;
7595 +}
7596 +
7597 +
7598 +#if defined(FIST_DEBUG) || defined(FIST_FILTER_SCA)
7599 +/*
7600 + * we now define delete_inode, because there are two VFS paths that may
7601 + * destroy an inode: one of them calls clear inode before doing everything
7602 + * else that's needed, and the other is fine. This way we truncate the inode
7603 + * size (and its pages) and then clear our own inode, which will do an iput
7604 + * on our and the lower inode.
7605 + */
7606 +STATIC void
7607 +mini_fo_delete_inode(inode_t *inode)
7608 +{
7609 + print_entry_location();
7610 +
7611 + fist_checkinode(inode, "mini_fo_delete_inode IN");
7612 + inode->i_size = 0; /* every f/s seems to do that */
7613 + clear_inode(inode);
7614 +
7615 + print_exit_location();
7616 +}
7617 +#endif /* defined(FIST_DEBUG) || defined(FIST_FILTER_SCA) */
7618 +
7619 +
7620 +/* final actions when unmounting a file system */
7621 +STATIC void
7622 +mini_fo_put_super(super_block_t *sb)
7623 +{
7624 + if (stopd(sb)) {
7625 + mntput(stopd(sb)->hidden_mnt);
7626 + mntput(stopd(sb)->hidden_mnt2);
7627 +
7628 + /* mk: no! dput(stopd(sb)->base_dir_dentry);
7629 + dput(stopd(sb)->storage_dir_dentry); */
7630 +
7631 + kfree(stopd(sb));
7632 + __stopd(sb) = NULL;
7633 + }
7634 +}
7635 +
7636 +
7637 +#ifdef NOT_NEEDED
7638 +/*
7639 + * This is called in do_umount before put_super.
7640 + * The superblock lock is not held yet.
7641 + * We probably do not need to define this or call write_super
7642 + * on the hidden_sb, because sync_supers() will get to hidden_sb
7643 + * sooner or later. But it is also called from file_fsync()...
7644 + */
7645 +STATIC void
7646 +mini_fo_write_super(super_block_t *sb)
7647 +{
7648 + return;
7649 +}
7650 +#endif /* NOT_NEEDED */
7651 +
7652 +
7653 +STATIC int
7654 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
7655 +mini_fo_statfs(super_block_t *sb, struct kstatfs *buf)
7656 +#else
7657 +mini_fo_statfs(super_block_t *sb, struct statfs *buf)
7658 +#endif
7659 +{
7660 + int err = 0;
7661 + super_block_t *hidden_sb;
7662 +
7663 + hidden_sb = stohs(sb);
7664 + err = vfs_statfs(hidden_sb, buf);
7665 +
7666 + return err;
7667 +}
7668 +
7669 +
7670 +/*
7671 + * XXX: not implemented. This is not allowed yet.
7672 + * Should we call this on the hidden_sb? Probably not.
7673 + */
7674 +STATIC int
7675 +mini_fo_remount_fs(super_block_t *sb, int *flags, char *data)
7676 +{
7677 + //printk(KERN_CRIT "mini_fo_remount_fs: WARNING, this function is umimplemented.\n");
7678 + return -ENOSYS;
7679 +}
7680 +
7681 +
7682 +/*
7683 + * Called by iput() when the inode reference count reached zero
7684 + * and the inode is not hashed anywhere. Used to clear anything
7685 + * that needs to be, before the inode is completely destroyed and put
7686 + * on the inode free list.
7687 + */
7688 +STATIC void
7689 +mini_fo_clear_inode(inode_t *inode)
7690 +{
7691 + /*
7692 + * Decrement a reference to a hidden_inode, which was incremented
7693 + * by our read_inode when it was created initially.
7694 + */
7695 +
7696 + /* release the wol_list */
7697 + if(S_ISDIR(inode->i_mode)) {
7698 + __meta_put_lists(inode);
7699 + }
7700 +
7701 + /* mk: fan out fun */
7702 + if(itohi(inode))
7703 + iput(itohi(inode));
7704 + if(itohi2(inode))
7705 + iput(itohi2(inode));
7706 +
7707 + // XXX: why this assertion fails?
7708 + // because it doesn't like us
7709 + // ASSERT((inode->i_state & I_DIRTY) == 0);
7710 + kfree(itopd(inode));
7711 + __itopd(inode) = NULL;
7712 +}
7713 +
7714 +
7715 +/*
7716 + * Called in do_umount() if the MNT_FORCE flag was used and this
7717 + * function is defined. See comment in linux/fs/super.c:do_umount().
7718 + * Used only in nfs, to kill any pending RPC tasks, so that subsequent
7719 + * code can actually succeed and won't leave tasks that need handling.
7720 + *
7721 + * PS. I wonder if this is somehow useful to undo damage that was
7722 + * left in the kernel after a user level file server (such as amd)
7723 + * dies.
7724 + */
7725 +STATIC void
7726 +mini_fo_umount_begin(super_block_t *sb)
7727 +{
7728 + super_block_t *hidden_sb;
7729 +
7730 + hidden_sb = stohs(sb);
7731 +
7732 + if (hidden_sb->s_op->umount_begin)
7733 + hidden_sb->s_op->umount_begin(hidden_sb);
7734 +
7735 +}
7736 +
7737 +
7738 +struct super_operations mini_fo_sops =
7739 +{
7740 + read_inode: mini_fo_read_inode,
7741 +#if defined(FIST_DEBUG) || defined(FIST_FILTER_SCA)
7742 + write_inode: mini_fo_write_inode,
7743 +#endif /* defined(FIST_DEBUG) || defined(FIST_FILTER_SCA) */
7744 + put_inode: mini_fo_put_inode,
7745 +#if defined(FIST_DEBUG) || defined(FIST_FILTER_SCA)
7746 + delete_inode: mini_fo_delete_inode,
7747 +#endif /* defined(FIST_DEBUG) || defined(FIST_FILTER_SCA) */
7748 + put_super: mini_fo_put_super,
7749 + statfs: mini_fo_statfs,
7750 + remount_fs: mini_fo_remount_fs,
7751 + clear_inode: mini_fo_clear_inode,
7752 + umount_begin: mini_fo_umount_begin,
7753 +};
Personal OpenWRT clone
This page took 0.33437 seconds and 5 git commands to generate.