[backfire] backport r26906
[openwrt/svn-archive/archive.git] / target / linux / generic-2.6 / patches-2.6.32 / 209-mini_fo.patch
1 --- a/fs/Kconfig
2 +++ b/fs/Kconfig
3 @@ -180,6 +180,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_lock(&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 +