gmane.linux.file-systems.cachefs.general

Re: [PATCH] fs: cachefiles: Add support for largefiles in filesystem caching

Suresh Jayaraman — 2012-05-22T05:05:58

Hello David,

This patch doesn't seem to have made it to linux-next (for May 21),
yet. Could you kindly re-check?

Thanks
Suresh



On Tue, May 1, 2012 at 2:43 PM, David Howells <dhowells< at >redhat.com> wrote:

NFS caching on the server-side

Abraham Aldaco — 2012-04-26T16:06:02

Hello,
I need help for configuring a NFS version 4 server for caching what clients read
from it. That is, the server has to cache locally (not the client) what any NFS
client reads from this server. The porpouse of this configuration if to relief
the work load of the server HDD.

Any suggestion or recommendation will be appreciated.
Abraham Aldaco
abraham.aldaco< at >gmail.com

nfs/fscache writeback cache

Sertaç Olgunsoylu — 2012-04-26T03:10:28

Hi,
First of all, I am not sure if this list is appropriate place to ask that
question but I think it is the most relevant one. I saw this project
proposal[1] on the Fedora Project's GSOC 2012 ideas page few weeks ago. It
proposes to add writeback caching support to NFS. I didn't apply to GSOC
since I am not a student but I want to spend my time working on that
project although this is not accepted by GSOC. I want to learn that is
there any ongoing effort on that side? If any, could you point me to that
so that i will not duplicate work and I can contribute to current project.

[1] -
http://fedoraproject.org/wiki/Summer_coding_ideas_for_2012#Linux_kernel_project

Thanks

Re: [PATCH] fs: cachefiles: Add support for largefiles in filesystem caching

Suresh Jayaraman — 2012-04-11T14:57:22

While preparing a similar patch to make cachefiles support files larger
than 2GB, I noticed that you had beaten me to it. Confirming that this
patch allows caching of larger files which would not be cached otherwise.

Tested-by: Suresh Jayaraman <sjayaraman< at >suse.com>


diff --git a/fs/cachefiles/rdwr.c b/fs/cachefiles/rdwr.c

oops when I mount nfs with -o fsc

fanchaoting — 2012-03-28T03:48:38

Hi: in nfs(RHEL6.x), i do as following. 
#cat /etc/exports
    /nfsroot      *(rw,no_root_squash,fsid=0,insecure)
#mount –t nfs4 –o fsc localhost:/   /nfsmnt
#sh create_file.sh

wait a while, i find oops.

PID: 4196   TASK: ffff88012365b580  CPU: 0   COMMAND: "sh"
 #0 [ffff880139435750] machine_kexec at ffffffff810310db
 #1 [ffff8801394357b0] crash_kexec at ffffffff810b63b2
 #2 [ffff880139435880] oops_end at ffffffff814dec50
 #3 [ffff8801394358b0] die at ffffffff8100f2fb
 #4 [ffff8801394358e0] do_trap at ffffffff814de544
 #5 [ffff880139435940] do_invalid_op at ffffffff8100ceb5
 #6 [ffff8801394359e0] invalid_op at ffffffff8100bf5b
    [exception RIP: __nfs_fscache_invalidate_page+121]
 #7 [ffff880139435ab0] nfs_invalidate_page at ffffffffa06fff6e [nfs]
 #8 [ffff880139435ad0] do_invalidatepage at ffffffff811243d5
 #9 [ffff880139435ae0] truncate_inode_page at ffffffff811245f2
#10 [ffff880139435b00] truncate_inode_pages_range at ffffffff811248f0
#11 [ffff880139435bf0] truncate_inode_pages at ffffffff81124c05

oops when I mount nfs with -o fsc

fanchaoting — 2012-03-29T01:53:27

Hi: in nfs(RHEL6.x), i do as following. 
#cat /etc/exports
    /nfsroot      *(rw,no_root_squash,fsid=0,insecure)
#mount –t nfs4 –o fsc localhost:/   /nfsmnt
#sh create_file.sh

wait a while, i find oops.

PID: 4196   TASK: ffff88012365b580  CPU: 0   COMMAND: "sh"
 #0 [ffff880139435750] machine_kexec at ffffffff810310db
 #1 [ffff8801394357b0] crash_kexec at ffffffff810b63b2
 #2 [ffff880139435880] oops_end at ffffffff814dec50
 #3 [ffff8801394358b0] die at ffffffff8100f2fb
 #4 [ffff8801394358e0] do_trap at ffffffff814de544
 #5 [ffff880139435940] do_invalid_op at ffffffff8100ceb5
 #6 [ffff8801394359e0] invalid_op at ffffffff8100bf5b
    [exception RIP: __nfs_fscache_invalidate_page+121]
 #7 [ffff880139435ab0] nfs_invalidate_page at ffffffffa06fff6e [nfs]
 #8 [ffff880139435ad0] do_invalidatepage at ffffffff811243d5
 #9 [ffff880139435ae0] truncate_inode_page at ffffffff811245f2
#10 [ffff880139435b00] truncate_inode_pages_range at ffffffff811248f0
#11 [ffff880139435bf0] truncate_inode_pages at ffffffff81124c05

Re: oops when I mount nfs with -o fsc

fanchaoting — 2012-03-29T01:50:46

fanchaoting 写道:



--
Linux-cachefs mailing list
Linux-cachefs< at >redhat.com
https://www.redhat.com/mailman/listinfo/linux-cachefs

Rebélate by self-management, first project of free software by which we bet all / Rebélate por la autogestión, primer proyecto de software libre por el que apostamos todas

Orquidea Salt mas — 2012-03-02T19:22:05

Inglés :

Many already we have contributed to the first project of free software
dedicated to self-management in this campaign of collective financing,
it collaborates and it spreads!/


Beginning campaign collective financing

http://www.goteo.org/project/rebelaos-publicacion-por-la-autogestion?lang=en


Login to enter with user of social networks and for would register in Goteo :

http://www.goteo.org/user/login?lang=en


Rebelaos! Publication by self-management A massive publication that
floods the public transport, the work centers, the parks, the
consumption centers, by means of distribution of 500,000 gratuitous
units, acting simultaneously in all sides and nowhere.

We announce the main tool of a vestibule Web for the management of
self-sustaining resources by means of Drupal, in addition in the
publication there will be an article dedicated to free software,
hardware, It is being prepared in inglès,  the machinery You can see
more details in the index of the
publication    https://n-1.cc/pg/file/re

Re: FS-Cache "Netfs" (nfs) Fedora 15/16/17

David Howells — 2012-02-21T18:14:26


Unless you're mounting an NFS fs with -o fsc immediately thereafter it should
do very little at this point, and even so, it shouldn't do much more unless
you've also loaded the cachefiles module and started up a cache.

Try:

echo 65535 >/sys/module/fscache/parameters/debug

David

FS-Cache "Netfs" (nfs) Fedora 15/16/17

Frank Murphy — 2012-02-21T17:41:39

Hi,

Am trying to figure out why during bootup,
at the following point across real and virt boxes.

eb 19 11:22:07 frank01 kernel: [  482.640618] FS-Cache: Loaded
Feb 19 11:22:07 frank01 kernel: [  482.672487] FS-Cache: Netfs 'nfs' 
registered for caching

It sits there for about 10 seconds, with no indication as to what's 
happening.


nfs mount during bootup can be autofs or fstab depending on box.


Is this still relevant for debugging FS-Cache:
https://www.redhat.com/archives/linux-cachefs/2010-February/msg00022.html

" You can also turn on NFS debugging for FS-Cache to see what it's doing:

echo $((0x800)) >/proc/sys/sunrpc/nfs_debug  "


kernels across boxes: 3.2* 3.3*

[PATCH 17/17] NFS: nfs_migrate_page() does not wait for FS-Cache to finish with a page

David Howells — 2012-02-08T21:19:35

nfs_migrate_page() does not wait for FS-Cache to finish with a page, probably
leading to the following bad-page-state:

 BUG: Bad page state in process python-bin  pfn:17d39b
 page:ffffea00053649e8 flags:004000000000100c count:0 mapcount:0 mapping:(null)
index:38686 (Tainted: G    B      ---------------- )
 Pid: 31053, comm: python-bin Tainted: G    B      ----------------
2.6.32-71.24.1.el6.x86_64 #1
 Call Trace:
 [<ffffffff8111bfe7>] bad_page+0x107/0x160
 [<ffffffff8111ee69>] free_hot_cold_page+0x1c9/0x220
 [<ffffffff8111ef19>] __pagevec_free+0x59/0xb0
 [<ffffffff8104b988>] ? flush_tlb_others_ipi+0x128/0x130
 [<ffffffff8112230c>] release_pages+0x21c/0x250
 [<ffffffff8115b92a>] ? remove_migration_pte+0x28a/0x2b0
 [<ffffffff8115f3f8>] ? mem_cgroup_get_reclaim_stat_from_page+0x18/0x70
 [<ffffffff81122687>] ____pagevec_lru_add+0x167/0x180
 [<ffffffff811226f8>] __lru_cache_add+0x58/0x70
 [<ffffffff81122731>] lru_cache_add_lru+0x21/0x40
 [<ffffffff81123f49>] putback_lru_page+0x69/0x100
 [<ffffffff8115c0bd>] migr

[PATCH 16/17] FS-Cache: Exclusive op submission can BUG if there's been an I/O error

David Howells — 2012-02-08T21:19:24

The function to submit an exclusive op (fscache_submit_exclusive_op()) can BUG
if there's been an I/O error because it may see the parent cache object in an
unexpected state.  It should only BUG if there hasn't been an I/O error.

In this case the problem was produced by remounting the cache partition to be
R/O.  The EROFS state was detected and the cache was aborted, but not
everything handled the aborting correctly.

SysRq : Emergency Remount R/O
EXT4-fs (sda6): re-mounted. Opts: (null)
Emergency Remount complete
CacheFiles: I/O Error: Failed to update xattr with error -30
FS-Cache: Cache cachefiles stopped due to I/O error
------------[ cut here ]------------
kernel BUG at fs/fscache/operation.c:128!
invalid opcode: 0000 [#1] SMP 
CPU 0 
Modules linked in: cachefiles nfs fscache auth_rpcgss nfs_acl lockd sunrpc

Pid: 6612, comm: kworker/u:2 Not tainted 3.1.0-rc8-fsdevel+ #1093                  /DG965RY
RIP: 0010:[<ffffffffa00739c0>]  [<ffffffffa00739c0>] fscache_submit_exclusive_op+0x2ad/0x2c2 [fscache]
R

[PATCH 15/17] FS-Cache: Limit the number of I/O error reports for a cache

David Howells — 2012-02-08T21:19:15

Limit the number of I/O error reports for a cache to 1 to prevent massive
amounts of noise.  After the first I/O error the cache is taken off line
automatically, so must be restarted to resume caching.

Signed-off-by: David Howells <dhowells< at >redhat.com>
---

 fs/fscache/cache.c |    8 ++++----
 1 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/fs/fscache/cache.c b/fs/fscache/cache.c
index 6a3c48a..b52aed1 100644
--- a/fs/fscache/cache.c
+++ b/fs/fscache/cache.c
< at >< at > -314,10 +314,10 < at >< at > EXPORT_SYMBOL(fscache_add_cache);
  */
 void fscache_io_error(struct fscache_cache *cache)
 {
-set_bit(FSCACHE_IOERROR, &cache->flags);
-
-printk(KERN_ERR "FS-Cache: Cache %s stopped due to I/O error\n",
-       cache->ops->name);
+if (!test_and_set_bit(FSCACHE_IOERROR, &cache->flags))
+printk(KERN_ERR "FS-Cache:"
+       " Cache '%s' stopped due to I/O error\n",
+       cache->ops->name);
 }
 EXPORT_SYMBOL(fscache_io_error);

[PATCH 14/17] FS-Cache: Don't mask off the object event mask when printing it

David Howells — 2012-02-08T21:19:03

Don't mask off the object event mask when printing it.  That way it can be seen
if threre are bits set that shouldn't be.

Signed-off-by: David Howells <dhowells< at >redhat.com>
---

 fs/cachefiles/namei.c    |    3 +--
 fs/fscache/object-list.c |    2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c
index a0358c2..0fd9b6d 100644
--- a/fs/cachefiles/namei.c
+++ b/fs/cachefiles/namei.c
< at >< at > -40,8 +40,7 < at >< at > void __cachefiles_printk_object(struct cachefiles_object *object,
 printk(KERN_ERR "%sobjstate=%s fl=%lx wbusy=%x ev=%lx[%lx]\n",
        prefix, fscache_object_states[object->fscache.state],
        object->fscache.flags, work_busy(&object->fscache.work),
-       object->fscache.events,
-       object->fscache.event_mask & FSCACHE_OBJECT_EVENTS_MASK);
+       object->fscache.events, object->fscache.event_mask);
 printk(KERN_ERR "%sops=%u inp=%u exc=%u\n",
        prefix, object->fscache.n_ops, object->fscache.n_in_progress,
        object->f

[PATCH 13/17] FS-Cache: Initialise the object event mask with the calculated mask

David Howells — 2012-02-08T21:18:53

Initialise the object event mask with the calculated mask rather than unmasking
undefined events also.

Signed-off-by: David Howells <dhowells< at >redhat.com>
---

 fs/fscache/object.c |    3 ++-
 1 files changed, 2 insertions(+), 1 deletions(-)

diff --git a/fs/fscache/object.c b/fs/fscache/object.c
index 80b5491..2ef8a08 100644
--- a/fs/fscache/object.c
+++ b/fs/fscache/object.c
< at >< at > -114,7 +114,8 < at >< at > static void fscache_object_state_machine(struct fscache_object *object)
 /* wait for the parent object to become ready */
 case FSCACHE_OBJECT_INIT:
 object->event_mask =
-ULONG_MAX & ~(1 << FSCACHE_OBJECT_EV_CLEARED);
+FSCACHE_OBJECT_EVENTS_MASK &
+~(1 << FSCACHE_OBJECT_EV_CLEARED);
 fscache_initialise_object(object);
 goto done;

[PATCH 12/17] FS-Cache: Convert the object event ID #defines into an enum

David Howells — 2012-02-08T21:18:44

Convert the fscache_object event IDs from #defines into an enum.  Also add an
extra label to the enum to carry the event count and redefine the event mask
in terms of that.

Signed-off-by: David Howells <dhowells< at >redhat.com>
---

 include/linux/fscache-cache.h |   26 +++++++++++++++++---------
 1 files changed, 17 insertions(+), 9 deletions(-)

diff --git a/include/linux/fscache-cache.h b/include/linux/fscache-cache.h
index 1e454ad..73e68c8 100644
--- a/include/linux/fscache-cache.h
+++ b/include/linux/fscache-cache.h
< at >< at > -338,6 +338,23 < at >< at > struct fscache_cookie {
 extern struct fscache_cookie fscache_fsdef_index;
 
 /*
+ * Event list for fscache_object::{event_mask,events}
+ */
+enum {
+FSCACHE_OBJECT_EV_REQUEUE,/* T if object should be requeued */
+FSCACHE_OBJECT_EV_UPDATE,/* T if object should be updated */
+FSCACHE_OBJECT_EV_INVALIDATE,/* T if cache requested object invalidation */
+FSCACHE_OBJECT_EV_CLEARED,/* T if accessors all gone */
+FSCACHE_OBJECT_EV_ERROR,/* T if fatal error occurred durin

[PATCH 10/17] NFS: Use FS-Cache invalidation

David Howells — 2012-02-08T21:18:23

Use the new FS-Cache invalidation facility from NFS to deal with foreign
changes being detected on the server rather than attempting to retire the old
cookie and get a new one.

The problem with the old method was that NFS did not wait for all outstanding
storage and retrieval ops on the cache to complete.  There was no automatic
wait between the calls to ->readpages() and calls to invalidate_inode_pages2()
as the latter can only wait on locked pages that have been added to the
pagecache (which they haven't yet on entry to ->readpages()).

This was leading to oopses like the one below when an outstanding read got cut
off from its cookie by a premature release.

BUG: unable to handle kernel NULL pointer dereference at 00000000000000a8
IP: [<ffffffffa0075118>] __fscache_read_or_alloc_pages+0x1dd/0x315 [fscache]
PGD 15889067 PUD 15890067 PMD 0
Oops: 0000 [#1] SMP
CPU 0
Modules linked in: cachefiles nfs fscache auth_rpcgss nfs_acl lockd sunrpc

Pid: 4544, comm: tar Not tainted 3.1.0-rc4-fsdevel+ #1064

[PATCH 09/17] CacheFiles: Implement invalidation

David Howells — 2012-02-08T21:18:13

Implement invalidation for CacheFiles.  This is in two parts:

 (1) Provide an invalidation method (which just truncates the backing file).

 (2) Abort attempts to copy anything read from the backing file whilst
     invalidation is in progress.

Question: CacheFiles uses truncation in a couple of places.  It has been using
notify_change() rather than sys_truncate() or something similar.  This means
it bypasses a bunch of checks and suchlike that it possibly should be making
(security, file locking, lease breaking, vfsmount write).  Should it be using
vfs_truncate() as added by a preceding patch or should it use notify_write()
and assume that anyone poking around in the cache files on disk gets
everything they deserve?

Signed-off-by: David Howells <dhowells< at >redhat.com>
---

 fs/cachefiles/interface.c |   49 +++++++++++++++++++++++++++++++++++++++++++++
 fs/cachefiles/rdwr.c      |    5 ++++-
 2 files changed, 53 insertions(+), 1 deletions(-)

diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.

[PATCH 08/17] VFS: Make more complete truncate operation available to CacheFiles

David Howells — 2012-02-08T21:18:03

Make a more complete truncate operation available to CacheFiles (including
security checks and suchlike) so that it can use this to clear invalidated
cache files.

Signed-off-by: David Howells <dhowells< at >redhat.com>
---

 fs/open.c          |   50 +++++++++++++++++++++++++++-----------------------
 include/linux/fs.h |    1 +
 2 files changed, 28 insertions(+), 23 deletions(-)

diff --git a/fs/open.c b/fs/open.c
index 77becc0..7535620 100644
--- a/fs/open.c
+++ b/fs/open.c
< at >< at > -61,33 +61,22 < at >< at > int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs,
 return ret;
 }
 
-static long do_sys_truncate(const char __user *pathname, loff_t length)
+long vfs_truncate(struct path *path, loff_t length)
 {
-struct path path;
 struct inode *inode;
-int error;
-
-error = -EINVAL;
-if (length < 0)/* sorry, but loff_t says... */
-goto out;
+long error;
 
-error = user_path(pathname, &path);
-if (error)
-goto out;
-inode = path.dentry->d_inode;
+inode = path->dentry->d_inode;
 
 /* For dir

[PATCH 07/17] FS-Cache: Provide proper invalidation

David Howells — 2012-02-08T21:17:52

Provide a proper invalidation method rather than relying on the netfs retiring
the cookie it has and getting a new one.  The problem with this is that isn't
easy for the netfs to make sure that it has completed/cancelled all its
outstanding storage and retrieval operations on the cookie it is retiring.

Instead, have the cache provide an invalidation method that will cancel or wait
for all currently outstanding operations before invalidating the cache, and
will cause new operations to queue up behind that.  Whilst invalidation is in
progress, some requests will be rejected until the cache can stack a barrier on
the operation queue to cause new operations to be deferred behind it.

Signed-off-by: David Howells <dhowells< at >redhat.com>
---

 Documentation/filesystems/caching/backend-api.txt |   12 ++++
 Documentation/filesystems/caching/netfs-api.txt   |   46 +++++++++++--
 Documentation/filesystems/caching/object.txt      |   23 ++++---
 fs/fscache/cookie.c                               |   60 ++++++++++++++++++

[PATCH 05/17] FS-Cache: Make cookie relinquishment wait for outstanding reads

David Howells — 2012-02-08T21:17:31

Make fscache_relinquish_cookie() log a warning and wait if there are any
outstanding reads left on the cookie it was given.

Signed-off-by: David Howells <dhowells< at >redhat.com>
---

 fs/fscache/cookie.c           |   18 ++++++++++++++----
 fs/fscache/operation.c        |   10 ++++++++--
 include/linux/fscache-cache.h |    1 +
 3 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/fs/fscache/cookie.c b/fs/fscache/cookie.c
index 0666996..66be9ec 100644
--- a/fs/fscache/cookie.c
+++ b/fs/fscache/cookie.c
< at >< at > -442,22 +442,32 < at >< at > void __fscache_relinquish_cookie(struct fscache_cookie *cookie, int retire)
 
 event = retire ? FSCACHE_OBJECT_EV_RETIRE : FSCACHE_OBJECT_EV_RELEASE;
 
+try_again:
 spin_lock(&cookie->lock);
 
 /* break links with all the active objects */
 while (!hlist_empty(&cookie->backing_objects)) {
+int n_reads;
 object = hlist_entry(cookie->backing_objects.first,
      struct fscache_object,
      cookie_link);
 
 _debug("RELEASE OBJ%x", object->debug_id);
 
-if (atomic