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