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