Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
067600c8cf
NetBSD/lib/libpuffs/dispatcher.c

1174 lines
26 KiB
C
Raw Normal View History

Fix regression that has been introduced when the lookup/reclaim race condition was addressed in libpuffs by counting lookups. The fix assumes that cookies map to struct puffs_cookie, which has not been documented as a requirement for filesystems using libpuffs. As an example, we got burnt by this assumption in libp2k (kern/46734), and we fixed bit by actually mapping libp2k cookies to struct puffs_node. It is unlikely, but there may be third party filesystems that use cookies unmapped to struct puffs_node, and they were left broken for now. - we introduce a puffs_init() flag PUFFS_FLAG_PNCOOKIE that let filesystems inform libpuffs that they map cookies to struct puffs_node. Is that flag is used, the lookup/reclaim race condition fix is enabled. We enable the flag for libp2k. - filesystems that use puffs_pn_new() obviouslty use struct puffs_node and gain PUFFS_FLAG_PNCOOKIE automatically even if they did not specify it in puffs_init(). This include all our PUFFS filesystem in-tree except libp2k. - for filesystems not willing to use struct puffs_node, we introduce a reclaim2 vnop, which is reclaim with an additionnal lookup count argument. This vnop let the filesystem implement the lookup/reclaim race fix on its own.
2012-08-16 13:25:43 +04:00
/* $NetBSD: dispatcher.c,v 1.44 2012/08/16 09:25:43 manu Exp $ */
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
/*
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
* Copyright (c) 2006, 2007, 2008 Antti Kantee. All Rights Reserved.
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
*
* Development of this software was supported by the
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
* Ulla Tuominen Foundation, the Finnish Cultural Foundation and
* Research Foundation of Helsinki University of Technology.
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
#if !defined(lint)
Fix regression that has been introduced when the lookup/reclaim race condition was addressed in libpuffs by counting lookups. The fix assumes that cookies map to struct puffs_cookie, which has not been documented as a requirement for filesystems using libpuffs. As an example, we got burnt by this assumption in libp2k (kern/46734), and we fixed bit by actually mapping libp2k cookies to struct puffs_node. It is unlikely, but there may be third party filesystems that use cookies unmapped to struct puffs_node, and they were left broken for now. - we introduce a puffs_init() flag PUFFS_FLAG_PNCOOKIE that let filesystems inform libpuffs that they map cookies to struct puffs_node. Is that flag is used, the lookup/reclaim race condition fix is enabled. We enable the flag for libp2k. - filesystems that use puffs_pn_new() obviouslty use struct puffs_node and gain PUFFS_FLAG_PNCOOKIE automatically even if they did not specify it in puffs_init(). This include all our PUFFS filesystem in-tree except libp2k. - for filesystems not willing to use struct puffs_node, we introduce a reclaim2 vnop, which is reclaim with an additionnal lookup count argument. This vnop let the filesystem implement the lookup/reclaim race fix on its own.
2012-08-16 13:25:43 +04:00
__RCSID("$NetBSD: dispatcher.c,v 1.44 2012/08/16 09:25:43 manu Exp $");
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
#endif /* !lint */
#include <sys/types.h>
dispatch PUFFS_VN_POLL
2007-05-18 17:53:54 +04:00
#include <sys/poll.h>
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
#include <assert.h>
#include <errno.h>
Add some very initial support for a threading worker model as an alternative to the (vastly superior ;) continuation model. This is very preliminary stuff and not compiled by default (which it even won't do without some other patches I cannot commit yet). The raison d'commit of the patch is a snippet which ensures proper in-order dispatching of all operations, including those which don't require a response. Previously many of them would be dispatched simultaneosly, e.g. fsync and reclaim on the same node, which obviously isn't all that nice for correct operation.
2007-10-26 21:35:01 +04:00
#include <pthread.h>
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
#include <puffs.h>
#include <puffsdump.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "puffs_priv.h"
Add PUFFS_KFLAG_CACHE_FS_TTL flag to puffs_init(3) to use name and attribute cache with filesystem provided TTL. lookup, create, mknod, mkdir, symlink, getattr and setattr messages have been extended so that attributes and their TTL can be provided by the filesytem. lookup, create, mknod, mkdir, and symlink messages are also extended so that the filesystem can provide name TTL. The filesystem updates attributes and TTL using puffs_pn_getvap(3), puffs_pn_getvattl(3), and puffs_pn_getcnttl(3)
2012-04-08 19:07:45 +04:00
#define PUFFS_USE_FS_TTL(pu) (pu->pu_flags & PUFFS_KFLAG_CACHE_FS_TTL)
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
static void dispatch(struct puffs_cc *);
Add some very initial support for a threading worker model as an alternative to the (vastly superior ;) continuation model. This is very preliminary stuff and not compiled by default (which it even won't do without some other patches I cannot commit yet). The raison d'commit of the patch is a snippet which ensures proper in-order dispatching of all operations, including those which don't require a response. Previously many of them would be dispatched simultaneosly, e.g. fsync and reclaim on the same node, which obviously isn't all that nice for correct operation.
2007-10-26 21:35:01 +04:00
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
/* for our eyes only */
void
puffs__ml_dispatch(struct puffs_usermount *pu, struct puffs_framebuf *pb)
{
struct puffs_cc *pcc = puffs_cc_getcc(pu);
struct puffs_req *preq;
Add some very initial support for a threading worker model as an alternative to the (vastly superior ;) continuation model. This is very preliminary stuff and not compiled by default (which it even won't do without some other patches I cannot commit yet). The raison d'commit of the patch is a snippet which ensures proper in-order dispatching of all operations, including those which don't require a response. Previously many of them would be dispatched simultaneosly, e.g. fsync and reclaim on the same node, which obviously isn't all that nice for correct operation.
2007-10-26 21:35:01 +04:00
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
pcc->pcc_pb = pb;
pcc->pcc_flags |= PCC_MLCONT;
dispatch(pcc);
Add some very initial support for a threading worker model as an alternative to the (vastly superior ;) continuation model. This is very preliminary stuff and not compiled by default (which it even won't do without some other patches I cannot commit yet). The raison d'commit of the patch is a snippet which ensures proper in-order dispatching of all operations, including those which don't require a response. Previously many of them would be dispatched simultaneosly, e.g. fsync and reclaim on the same node, which obviously isn't all that nice for correct operation.
2007-10-26 21:35:01 +04:00
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
/* Put result to kernel sendqueue if necessary */
preq = puffs__framebuf_getdataptr(pcc->pcc_pb);
if (PUFFSOP_WANTREPLY(preq->preq_opclass)) {
if (pu->pu_flags & PUFFS_FLAG_OPDUMP)
puffsdump_rv(preq);
Add some very initial support for a threading worker model as an alternative to the (vastly superior ;) continuation model. This is very preliminary stuff and not compiled by default (which it even won't do without some other patches I cannot commit yet). The raison d'commit of the patch is a snippet which ensures proper in-order dispatching of all operations, including those which don't require a response. Previously many of them would be dispatched simultaneosly, e.g. fsync and reclaim on the same node, which obviously isn't all that nice for correct operation.
2007-10-26 21:35:01 +04:00
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
puffs_framev_enqueue_justsend(pu, pu->pu_fd,
pcc->pcc_pb, 0, 0);
} else {
puffs_framebuf_destroy(pcc->pcc_pb);
}
Add some very initial support for a threading worker model as an alternative to the (vastly superior ;) continuation model. This is very preliminary stuff and not compiled by default (which it even won't do without some other patches I cannot commit yet). The raison d'commit of the patch is a snippet which ensures proper in-order dispatching of all operations, including those which don't require a response. Previously many of them would be dispatched simultaneosly, e.g. fsync and reclaim on the same node, which obviously isn't all that nice for correct operation.
2007-10-26 21:35:01 +04:00
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
/* who needs information when you're living on borrowed time? */
if (pcc->pcc_flags & PCC_BORROWED) {
puffs_cc_yield(pcc); /* back to borrow source */
Add some very initial support for a threading worker model as an alternative to the (vastly superior ;) continuation model. This is very preliminary stuff and not compiled by default (which it even won't do without some other patches I cannot commit yet). The raison d'commit of the patch is a snippet which ensures proper in-order dispatching of all operations, including those which don't require a response. Previously many of them would be dispatched simultaneosly, e.g. fsync and reclaim on the same node, which obviously isn't all that nice for correct operation.
2007-10-26 21:35:01 +04:00
}
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
pcc->pcc_flags = 0;
Add some very initial support for a threading worker model as an alternative to the (vastly superior ;) continuation model. This is very preliminary stuff and not compiled by default (which it even won't do without some other patches I cannot commit yet). The raison d'commit of the patch is a snippet which ensures proper in-order dispatching of all operations, including those which don't require a response. Previously many of them would be dispatched simultaneosly, e.g. fsync and reclaim on the same node, which obviously isn't all that nice for correct operation.
2007-10-26 21:35:01 +04:00
}
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
/* public, but not really tested and only semi-supported */
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
int
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
puffs_dispatch_create(struct puffs_usermount *pu, struct puffs_framebuf *pb,
struct puffs_cc **pccp)
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
{
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
struct puffs_cc *pcc;
Add error notifications, which are used to deliver errors from the kernel to the file server for silly things the file server did, e.g. attempting to create a file with size VSIZENOTSET. The file server can handle these as it chooses, but the default action is for it to throw its hands in the air and sing "goodbye, cruel world, it's over, walk on by".
2007-09-28 01:14:49 +04:00
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
if (puffs__cc_create(pu, dispatch, &pcc) == -1)
return -1;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
pcc->pcc_pb = pb;
*pccp = pcc;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
return 0;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
}
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
int
puffs_dispatch_exec(struct puffs_cc *pcc, struct puffs_framebuf **pbp)
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
{
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
int rv;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
puffs_cc_continue(pcc);
Part 3/n of extensive changes to message handling: Get rid of the original puffs_req(3) framework and use puffs_framebuf(3) instead for file system requests. It has the advantage of being suitable for transporting a distributed message passing protocol and therefore us being able to run the file system server on any host. Ok, puffs is not quite here yet: libpuffs needs to grow request routing support and the message contents need to be munged into a host independent format. Saying which format would be telling, but it might begin with an X, end in an L and have the 13th character in the middle. Keep an eye out for the sequels: Parts 3+m/n.
2007-12-05 00:24:10 +03:00
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
if (pcc->pcc_flags & PCC_DONE) {
rv = 1;
*pbp = pcc->pcc_pb;
pcc->pcc_flags = 0;
puffs__cc_destroy(pcc, 0);
} else {
rv = 0;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
}
Part 3/n of extensive changes to message handling: Get rid of the original puffs_req(3) framework and use puffs_framebuf(3) instead for file system requests. It has the advantage of being suitable for transporting a distributed message passing protocol and therefore us being able to run the file system server on any host. Ok, puffs is not quite here yet: libpuffs needs to grow request routing support and the message contents need to be munged into a host independent format. Saying which format would be telling, but it might begin with an X, end in an L and have the 13th character in the middle. Keep an eye out for the sequels: Parts 3+m/n.
2007-12-05 00:24:10 +03:00
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
return rv;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
}
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
static void
dispatch(struct puffs_cc *pcc)
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
{
struct puffs_usermount *pu = pcc->pcc_pu;
struct puffs_ops *pops = &pu->pu_ops;
Part 3/n of extensive changes to message handling: Get rid of the original puffs_req(3) framework and use puffs_framebuf(3) instead for file system requests. It has the advantage of being suitable for transporting a distributed message passing protocol and therefore us being able to run the file system server on any host. Ok, puffs is not quite here yet: libpuffs needs to grow request routing support and the message contents need to be munged into a host independent format. Saying which format would be telling, but it might begin with an X, end in an L and have the 13th character in the middle. Keep an eye out for the sequels: Parts 3+m/n.
2007-12-05 00:24:10 +03:00
struct puffs_req *preq = puffs__framebuf_getdataptr(pcc->pcc_pb);
Reserve enough memory for ops which return more than they receive.
2008-03-20 18:28:03 +03:00
void *auxbuf; /* help with typecasting */
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t opcookie;
Fix regression that has been introduced when the lookup/reclaim race condition was addressed in libpuffs by counting lookups. The fix assumes that cookies map to struct puffs_cookie, which has not been documented as a requirement for filesystems using libpuffs. As an example, we got burnt by this assumption in libp2k (kern/46734), and we fixed bit by actually mapping libp2k cookies to struct puffs_node. It is unlikely, but there may be third party filesystems that use cookies unmapped to struct puffs_node, and they were left broken for now. - we introduce a puffs_init() flag PUFFS_FLAG_PNCOOKIE that let filesystems inform libpuffs that they map cookies to struct puffs_node. Is that flag is used, the lookup/reclaim race condition fix is enabled. We enable the flag for libp2k. - filesystems that use puffs_pn_new() obviouslty use struct puffs_node and gain PUFFS_FLAG_PNCOOKIE automatically even if they did not specify it in puffs_init(). This include all our PUFFS filesystem in-tree except libp2k. - for filesystems not willing to use struct puffs_node, we introduce a reclaim2 vnop, which is reclaim with an additionnal lookup count argument. This vnop let the filesystem implement the lookup/reclaim race fix on its own.
2012-08-16 13:25:43 +04:00
int error = 0, buildpath, pncookie;
Reserve enough memory for ops which return more than they receive.
2008-03-20 18:28:03 +03:00
/* XXX: smaller hammer, please */
if ((PUFFSOP_OPCLASS(preq->preq_opclass == PUFFSOP_VFS &&
preq->preq_optype == PUFFS_VFS_VPTOFH)) ||
(PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_VN &&
(preq->preq_optype == PUFFS_VN_READDIR
|| preq->preq_optype == PUFFS_VN_READ))) {
if (puffs_framebuf_reserve_space(pcc->pcc_pb,
PUFFS_MSG_MAXSIZE) == -1)
error = errno;
preq = puffs__framebuf_getdataptr(pcc->pcc_pb);
}
auxbuf = preq;
opcookie = preq->preq_cookie;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
assert((pcc->pcc_flags & PCC_DONE) == 0);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
buildpath = pu->pu_flags & PUFFS_FLAG_BUILDPATH;
Fix regression that has been introduced when the lookup/reclaim race condition was addressed in libpuffs by counting lookups. The fix assumes that cookies map to struct puffs_cookie, which has not been documented as a requirement for filesystems using libpuffs. As an example, we got burnt by this assumption in libp2k (kern/46734), and we fixed bit by actually mapping libp2k cookies to struct puffs_node. It is unlikely, but there may be third party filesystems that use cookies unmapped to struct puffs_node, and they were left broken for now. - we introduce a puffs_init() flag PUFFS_FLAG_PNCOOKIE that let filesystems inform libpuffs that they map cookies to struct puffs_node. Is that flag is used, the lookup/reclaim race condition fix is enabled. We enable the flag for libp2k. - filesystems that use puffs_pn_new() obviouslty use struct puffs_node and gain PUFFS_FLAG_PNCOOKIE automatically even if they did not specify it in puffs_init(). This include all our PUFFS filesystem in-tree except libp2k. - for filesystems not willing to use struct puffs_node, we introduce a reclaim2 vnop, which is reclaim with an additionnal lookup count argument. This vnop let the filesystem implement the lookup/reclaim race fix on its own.
2012-08-16 13:25:43 +04:00
pncookie = pu->pu_flags & PUFFS_FLAG_PNCOOKIE;
assert(!buildpath || pncookie);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
preq->preq_setbacks = 0;
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
if (pu->pu_flags & PUFFS_FLAG_OPDUMP)
puffsdump_req(preq);
puffs__cc_setcaller(pcc, preq->preq_pid, preq->preq_lid);
/* pre-operation */
Add possibility to set pre- and post callbacks which will be called for all operations before or after executing the specific callback (the api is not be final yet, though).
2007-10-28 21:40:30 +03:00
if (pu->pu_oppre)
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
pu->pu_oppre(pu);
Add possibility to set pre- and post callbacks which will be called for all operations before or after executing the specific callback (the api is not be final yet, though).
2007-10-28 21:40:30 +03:00
Reserve enough memory for ops which return more than they receive.
2008-03-20 18:28:03 +03:00
if (error)
goto out;
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
/* Execute actual operation */
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_VFS) {
switch (preq->preq_optype) {
case PUFFS_VFS_UNMOUNT:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vfsmsg_unmount *auxt = auxbuf;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
PU_SETSTATE(pu, PUFFS_STATE_UNMOUNTING);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_fs_unmount(pu, auxt->pvfsr_flags);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (!error)
PU_SETSTATE(pu, PUFFS_STATE_UNMOUNTED);
else
PU_SETSTATE(pu, PUFFS_STATE_RUNNING);
break;
}
case PUFFS_VFS_STATVFS:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vfsmsg_statvfs *auxt = auxbuf;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_fs_statvfs(pu, &auxt->pvfsr_sb);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VFS_SYNC:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vfsmsg_sync *auxt = auxbuf;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_MAKECRED(pcr, &auxt->pvfsr_cred);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_fs_sync(pu,
Remove "puffs_cid" from the puffs interface following l-removal from the kernel vfs interfaces. puffs_cc_getcaller(pcc) can be used now should the same information be desired.
2007-11-27 14:31:17 +03:00
auxt->pvfsr_waitfor, pcr);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VFS_FHTOVP:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vfsmsg_fhtonode *auxt = auxbuf;
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
struct puffs_newinfo pni;
pni.pni_cookie = &auxt->pvfsr_fhcookie;
pni.pni_vtype = &auxt->pvfsr_vtype;
pni.pni_size = &auxt->pvfsr_size;
pni.pni_rdev = &auxt->pvfsr_rdev;
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
pni.pni_va = NULL;
pni.pni_va_ttl = NULL;
pni.pni_cn_ttl = NULL;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_fs_fhtonode(pu, auxt->pvfsr_data,
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
auxt->pvfsr_dsize, &pni);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VFS_VPTOFH:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vfsmsg_nodetofh *auxt = auxbuf;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_fs_nodetofh(pu,
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
auxt->pvfsr_fhcookie, auxt->pvfsr_data,
&auxt->pvfsr_dsize);
break;
}
* support extended attributes * bump major due to structure growth * add some spare space * remove ABI sillyness
2010-05-21 14:50:52 +04:00
case PUFFS_VFS_EXTATTRCTL:
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
{
* support extended attributes * bump major due to structure growth * add some spare space * remove ABI sillyness
2010-05-21 14:50:52 +04:00
struct puffs_vfsmsg_extattrctl *auxt = auxbuf;
const char *attrname;
int flags;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
* support extended attributes * bump major due to structure growth * add some spare space * remove ABI sillyness
2010-05-21 14:50:52 +04:00
if (pops->puffs_fs_extattrctl == NULL) {
error = EOPNOTSUPP;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
* support extended attributes * bump major due to structure growth * add some spare space * remove ABI sillyness
2010-05-21 14:50:52 +04:00
}
if (auxt->pvfsr_flags & PUFFS_EXTATTRCTL_HASATTRNAME)
attrname = auxt->pvfsr_attrname;
else
attrname = NULL;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
* support extended attributes * bump major due to structure growth * add some spare space * remove ABI sillyness
2010-05-21 14:50:52 +04:00
flags = auxt->pvfsr_flags & PUFFS_EXTATTRCTL_HASNODE;
error = pops->puffs_fs_extattrctl(pu, auxt->pvfsr_cmd,
opcookie, flags,
auxt->pvfsr_attrnamespace, attrname);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
default:
/*
* I guess the kernel sees this one coming
*/
error = EINVAL;
break;
}
/* XXX: audit return values */
/* XXX: sync with kernel */
} else if (PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_VN) {
switch (preq->preq_optype) {
case PUFFS_VN_LOOKUP:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_lookup *auxt = auxbuf;
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
struct puffs_newinfo pni;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
struct puffs_cn pcn;
Add PUFFS_KFLAG_CACHE_FS_TTL flag to puffs_init(3) to use name and attribute cache with filesystem provided TTL. lookup, create, mknod, mkdir, symlink, getattr and setattr messages have been extended so that attributes and their TTL can be provided by the filesytem. lookup, create, mknod, mkdir, and symlink messages are also extended so that the filesystem can provide name TTL. The filesystem updates attributes and TTL using puffs_pn_getvap(3), puffs_pn_getvattl(3), and puffs_pn_getcnttl(3)
2012-04-08 19:07:45 +04:00
struct puffs_node *pn = NULL;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
pcn.pcn_pkcnp = &auxt->pvnr_cn;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
pni.pni_cookie = &auxt->pvnr_newnode;
pni.pni_vtype = &auxt->pvnr_vtype;
pni.pni_size = &auxt->pvnr_size;
pni.pni_rdev = &auxt->pvnr_rdev;
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
pni.pni_va = &auxt->pvnr_va;
pni.pni_va_ttl = &auxt->pvnr_va_ttl;
pni.pni_cn_ttl = &auxt->pvnr_cn_ttl;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (buildpath) {
error = puffs_path_pcnbuild(pu, &pcn, opcookie);
if (error)
break;
}
/* lookup *must* be present */
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_lookup(pu, opcookie,
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
&pni, &pcn);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (buildpath) {
if (error) {
pu->pu_pathfree(pu, &pcn.pcn_po_full);
} else {
/*
* did we get a new node or a
* recycled node?
*/
pn = PU_CMAP(pu, auxt->pvnr_newnode);
if (pn->pn_po.po_path == NULL)
pn->pn_po = pcn.pcn_po_full;
else
pu->pu_pathfree(pu,
&pcn.pcn_po_full);
}
}
- Improve PUFFS_KFLAG_CACHE_FS_TTL by reclaiming older inactive nodes. The normal kernel behavior is to retain inactive nodes in the freelist until it runs out of vnodes. This has some merit for local filesystems, where the cost of an allocation is about the same as the cost of a lookup. But that situation is not true for distributed filesystems. On the other hand, keeping inactive nodes for a long time hold memory in the file server process, and when the kernel runs out of vnodes, it produce reclaim avalanches that increase lattency for other operations. We do not reclaim inactive vnodes immediatly either, as they may be looked up again shortly. Instead we introduce a grace time and we reclaim nodes that have been inactive beyond the grace time. - Fix lookup/reclaim race condition. The above improvement undercovered a race condition between lookup and reclaim. If we reclaimed a vnode associated with a userland cookie while a lookup returning that same cookiewas inprogress, then the kernel ends up with a vnode associated with a cookie that has been reclaimed in userland. Next operation on the cookie will crash (or at least confuse) the filesystem. We fix this by introducing a lookup count in kernel and userland. On reclaim, the kernel sends the count, which enable userland to detect situation where it initiated a lookup that is not completed in kernel. In such a situation, the reclaim must be ignored, as the node is about to be looked up again.
2012-07-21 09:17:10 +04:00
Fix regression that has been introduced when the lookup/reclaim race condition was addressed in libpuffs by counting lookups. The fix assumes that cookies map to struct puffs_cookie, which has not been documented as a requirement for filesystems using libpuffs. As an example, we got burnt by this assumption in libp2k (kern/46734), and we fixed bit by actually mapping libp2k cookies to struct puffs_node. It is unlikely, but there may be third party filesystems that use cookies unmapped to struct puffs_node, and they were left broken for now. - we introduce a puffs_init() flag PUFFS_FLAG_PNCOOKIE that let filesystems inform libpuffs that they map cookies to struct puffs_node. Is that flag is used, the lookup/reclaim race condition fix is enabled. We enable the flag for libp2k. - filesystems that use puffs_pn_new() obviouslty use struct puffs_node and gain PUFFS_FLAG_PNCOOKIE automatically even if they did not specify it in puffs_init(). This include all our PUFFS filesystem in-tree except libp2k. - for filesystems not willing to use struct puffs_node, we introduce a reclaim2 vnop, which is reclaim with an additionnal lookup count argument. This vnop let the filesystem implement the lookup/reclaim race fix on its own.
2012-08-16 13:25:43 +04:00
if (pncookie && !error) {
- Improve PUFFS_KFLAG_CACHE_FS_TTL by reclaiming older inactive nodes. The normal kernel behavior is to retain inactive nodes in the freelist until it runs out of vnodes. This has some merit for local filesystems, where the cost of an allocation is about the same as the cost of a lookup. But that situation is not true for distributed filesystems. On the other hand, keeping inactive nodes for a long time hold memory in the file server process, and when the kernel runs out of vnodes, it produce reclaim avalanches that increase lattency for other operations. We do not reclaim inactive vnodes immediatly either, as they may be looked up again shortly. Instead we introduce a grace time and we reclaim nodes that have been inactive beyond the grace time. - Fix lookup/reclaim race condition. The above improvement undercovered a race condition between lookup and reclaim. If we reclaimed a vnode associated with a userland cookie while a lookup returning that same cookiewas inprogress, then the kernel ends up with a vnode associated with a cookie that has been reclaimed in userland. Next operation on the cookie will crash (or at least confuse) the filesystem. We fix this by introducing a lookup count in kernel and userland. On reclaim, the kernel sends the count, which enable userland to detect situation where it initiated a lookup that is not completed in kernel. In such a situation, the reclaim must be ignored, as the node is about to be looked up again.
2012-07-21 09:17:10 +04:00
if (pn == NULL)
pn = PU_CMAP(pu, auxt->pvnr_newnode);
pn->pn_nlookup++;
}
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VN_CREATE:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_create *auxt = auxbuf;
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
struct puffs_newinfo pni;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
struct puffs_cn pcn;
Fix race condition between (create|mknod|mkdir|symlino) and reclaim, just like we did it between lookup and reclaim.
2012-08-10 12:42:10 +04:00
struct puffs_node *pn = NULL;
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (pops->puffs_node_create == NULL) {
error = 0;
break;
}
pcn.pcn_pkcnp = &auxt->pvnr_cn;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
memset(&pni, 0, sizeof(pni));
pni.pni_cookie = &auxt->pvnr_newnode;
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
pni.pni_va = &auxt->pvnr_va;
pni.pni_va_ttl = &auxt->pvnr_va_ttl;
pni.pni_cn_ttl = &auxt->pvnr_cn_ttl;
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (buildpath) {
error = puffs_path_pcnbuild(pu, &pcn, opcookie);
if (error)
break;
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_create(pu,
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
opcookie, &pni, &pcn, &auxt->pvnr_va);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (buildpath) {
if (error) {
pu->pu_pathfree(pu, &pcn.pcn_po_full);
} else {
pn = PU_CMAP(pu, auxt->pvnr_newnode);
pn->pn_po = pcn.pcn_po_full;
}
}
Fix regression that has been introduced when the lookup/reclaim race condition was addressed in libpuffs by counting lookups. The fix assumes that cookies map to struct puffs_cookie, which has not been documented as a requirement for filesystems using libpuffs. As an example, we got burnt by this assumption in libp2k (kern/46734), and we fixed bit by actually mapping libp2k cookies to struct puffs_node. It is unlikely, but there may be third party filesystems that use cookies unmapped to struct puffs_node, and they were left broken for now. - we introduce a puffs_init() flag PUFFS_FLAG_PNCOOKIE that let filesystems inform libpuffs that they map cookies to struct puffs_node. Is that flag is used, the lookup/reclaim race condition fix is enabled. We enable the flag for libp2k. - filesystems that use puffs_pn_new() obviouslty use struct puffs_node and gain PUFFS_FLAG_PNCOOKIE automatically even if they did not specify it in puffs_init(). This include all our PUFFS filesystem in-tree except libp2k. - for filesystems not willing to use struct puffs_node, we introduce a reclaim2 vnop, which is reclaim with an additionnal lookup count argument. This vnop let the filesystem implement the lookup/reclaim race fix on its own.
2012-08-16 13:25:43 +04:00
if (pncookie && !error) {
Fix race condition between (create|mknod|mkdir|symlino) and reclaim, just like we did it between lookup and reclaim.
2012-08-10 12:42:10 +04:00
if (pn == NULL)
pn = PU_CMAP(pu, auxt->pvnr_newnode);
pn->pn_nlookup++;
}
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VN_MKNOD:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_mknod *auxt = auxbuf;
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
struct puffs_newinfo pni;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
struct puffs_cn pcn;
Fix race condition between (create|mknod|mkdir|symlino) and reclaim, just like we did it between lookup and reclaim.
2012-08-10 12:42:10 +04:00
struct puffs_node *pn = NULL;
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (pops->puffs_node_mknod == NULL) {
error = 0;
break;
}
pcn.pcn_pkcnp = &auxt->pvnr_cn;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
memset(&pni, 0, sizeof(pni));
pni.pni_cookie = &auxt->pvnr_newnode;
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
pni.pni_va = &auxt->pvnr_va;
pni.pni_va_ttl = &auxt->pvnr_va_ttl;
pni.pni_cn_ttl = &auxt->pvnr_cn_ttl;
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (buildpath) {
error = puffs_path_pcnbuild(pu, &pcn, opcookie);
if (error)
break;
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_mknod(pu,
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
opcookie, &pni, &pcn, &auxt->pvnr_va);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (buildpath) {
if (error) {
pu->pu_pathfree(pu, &pcn.pcn_po_full);
} else {
pn = PU_CMAP(pu, auxt->pvnr_newnode);
pn->pn_po = pcn.pcn_po_full;
}
}
Fix regression that has been introduced when the lookup/reclaim race condition was addressed in libpuffs by counting lookups. The fix assumes that cookies map to struct puffs_cookie, which has not been documented as a requirement for filesystems using libpuffs. As an example, we got burnt by this assumption in libp2k (kern/46734), and we fixed bit by actually mapping libp2k cookies to struct puffs_node. It is unlikely, but there may be third party filesystems that use cookies unmapped to struct puffs_node, and they were left broken for now. - we introduce a puffs_init() flag PUFFS_FLAG_PNCOOKIE that let filesystems inform libpuffs that they map cookies to struct puffs_node. Is that flag is used, the lookup/reclaim race condition fix is enabled. We enable the flag for libp2k. - filesystems that use puffs_pn_new() obviouslty use struct puffs_node and gain PUFFS_FLAG_PNCOOKIE automatically even if they did not specify it in puffs_init(). This include all our PUFFS filesystem in-tree except libp2k. - for filesystems not willing to use struct puffs_node, we introduce a reclaim2 vnop, which is reclaim with an additionnal lookup count argument. This vnop let the filesystem implement the lookup/reclaim race fix on its own.
2012-08-16 13:25:43 +04:00
if (pncookie && !error) {
Fix race condition between (create|mknod|mkdir|symlino) and reclaim, just like we did it between lookup and reclaim.
2012-08-10 12:42:10 +04:00
if (pn == NULL)
pn = PU_CMAP(pu, auxt->pvnr_newnode);
pn->pn_nlookup++;
}
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VN_OPEN:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_open *auxt = auxbuf;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (pops->puffs_node_open == NULL) {
error = 0;
break;
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_open(pu,
Remove "puffs_cid" from the puffs interface following l-removal from the kernel vfs interfaces. puffs_cc_getcaller(pcc) can be used now should the same information be desired.
2007-11-27 14:31:17 +03:00
opcookie, auxt->pvnr_mode, pcr);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VN_CLOSE:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_close *auxt = auxbuf;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (pops->puffs_node_close == NULL) {
error = 0;
break;
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_close(pu,
Remove "puffs_cid" from the puffs interface following l-removal from the kernel vfs interfaces. puffs_cc_getcaller(pcc) can be used now should the same information be desired.
2007-11-27 14:31:17 +03:00
opcookie, auxt->pvnr_fflag, pcr);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VN_ACCESS:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_access *auxt = auxbuf;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (pops->puffs_node_access == NULL) {
error = 0;
break;
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_access(pu,
Remove "puffs_cid" from the puffs interface following l-removal from the kernel vfs interfaces. puffs_cc_getcaller(pcc) can be used now should the same information be desired.
2007-11-27 14:31:17 +03:00
opcookie, auxt->pvnr_mode, pcr);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VN_GETATTR:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_getattr *auxt = auxbuf;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
if (PUFFS_USE_FS_TTL(pu)) {
if (pops->puffs_node_getattr_ttl == NULL) {
error = EOPNOTSUPP;
break;
}
Add PUFFS_KFLAG_CACHE_FS_TTL flag to puffs_init(3) to use name and attribute cache with filesystem provided TTL. lookup, create, mknod, mkdir, symlink, getattr and setattr messages have been extended so that attributes and their TTL can be provided by the filesytem. lookup, create, mknod, mkdir, and symlink messages are also extended so that the filesystem can provide name TTL. The filesystem updates attributes and TTL using puffs_pn_getvap(3), puffs_pn_getvattl(3), and puffs_pn_getcnttl(3)
2012-04-08 19:07:45 +04:00
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
error = pops->puffs_node_getattr_ttl(pu,
opcookie, &auxt->pvnr_va, pcr,
&auxt->pvnr_va_ttl);
} else {
if (pops->puffs_node_getattr == NULL) {
error = EOPNOTSUPP;
break;
}
Add PUFFS_KFLAG_CACHE_FS_TTL flag to puffs_init(3) to use name and attribute cache with filesystem provided TTL. lookup, create, mknod, mkdir, symlink, getattr and setattr messages have been extended so that attributes and their TTL can be provided by the filesytem. lookup, create, mknod, mkdir, and symlink messages are also extended so that the filesystem can provide name TTL. The filesystem updates attributes and TTL using puffs_pn_getvap(3), puffs_pn_getvattl(3), and puffs_pn_getcnttl(3)
2012-04-08 19:07:45 +04:00
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
error = pops->puffs_node_getattr(pu,
opcookie, &auxt->pvnr_va, pcr);
Add PUFFS_KFLAG_CACHE_FS_TTL flag to puffs_init(3) to use name and attribute cache with filesystem provided TTL. lookup, create, mknod, mkdir, symlink, getattr and setattr messages have been extended so that attributes and their TTL can be provided by the filesytem. lookup, create, mknod, mkdir, and symlink messages are also extended so that the filesystem can provide name TTL. The filesystem updates attributes and TTL using puffs_pn_getvap(3), puffs_pn_getvattl(3), and puffs_pn_getcnttl(3)
2012-04-08 19:07:45 +04:00
}
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VN_SETATTR:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_setattr *auxt = auxbuf;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
if (PUFFS_USE_FS_TTL(pu)) {
Pass the FAF flag to handlers: - setattr_ttl is updated to add a flag argument. Since it was not present in a previous release, we can change its API - write2 is introduced, this is write with an extra flag for FAF. - fsync already has the FAF information in a flag and needs no change - for other operations, FAF is unconditional
2012-06-27 17:25:23 +04:00
int xflag = 0;
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
if (pops->puffs_node_setattr_ttl == NULL) {
error = EOPNOTSUPP;
break;
}
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
Pass the FAF flag to handlers: - setattr_ttl is updated to add a flag argument. Since it was not present in a previous release, we can change its API - write2 is introduced, this is write with an extra flag for FAF. - fsync already has the FAF information in a flag and needs no change - for other operations, FAF is unconditional
2012-06-27 17:25:23 +04:00
if (!PUFFSOP_WANTREPLY(preq->preq_opclass))
xflag |= PUFFS_SETATTR_FAF;
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
error = pops->puffs_node_setattr_ttl(pu,
opcookie, &auxt->pvnr_va, pcr,
Pass the FAF flag to handlers: - setattr_ttl is updated to add a flag argument. Since it was not present in a previous release, we can change its API - write2 is introduced, this is write with an extra flag for FAF. - fsync already has the FAF information in a flag and needs no change - for other operations, FAF is unconditional
2012-06-27 17:25:23 +04:00
&auxt->pvnr_va_ttl, xflag);
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
} else {
if (pops->puffs_node_setattr == NULL) {
error = EOPNOTSUPP;
break;
}
Add PUFFS_KFLAG_CACHE_FS_TTL flag to puffs_init(3) to use name and attribute cache with filesystem provided TTL. lookup, create, mknod, mkdir, symlink, getattr and setattr messages have been extended so that attributes and their TTL can be provided by the filesytem. lookup, create, mknod, mkdir, and symlink messages are also extended so that the filesystem can provide name TTL. The filesystem updates attributes and TTL using puffs_pn_getvap(3), puffs_pn_getvattl(3), and puffs_pn_getcnttl(3)
2012-04-08 19:07:45 +04:00
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
error = pops->puffs_node_setattr(pu,
opcookie, &auxt->pvnr_va, pcr);
}
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VN_MMAP:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_mmap *auxt = auxbuf;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (pops->puffs_node_mmap == NULL) {
error = 0;
break;
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_mmap(pu,
Remove "puffs_cid" from the puffs interface following l-removal from the kernel vfs interfaces. puffs_cc_getcaller(pcc) can be used now should the same information be desired.
2007-11-27 14:31:17 +03:00
opcookie, auxt->pvnr_prot, pcr);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VN_FSYNC:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_fsync *auxt = auxbuf;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (pops->puffs_node_fsync == NULL) {
error = 0;
break;
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_fsync(pu, opcookie, pcr,
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
auxt->pvnr_flags, auxt->pvnr_offlo,
Remove "puffs_cid" from the puffs interface following l-removal from the kernel vfs interfaces. puffs_cc_getcaller(pcc) can be used now should the same information be desired.
2007-11-27 14:31:17 +03:00
auxt->pvnr_offhi);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VN_SEEK:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_seek *auxt = auxbuf;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (pops->puffs_node_seek == NULL) {
error = 0;
break;
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_seek(pu,
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
opcookie, auxt->pvnr_oldoff,
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
auxt->pvnr_newoff, pcr);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VN_REMOVE:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_remove *auxt = auxbuf;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
struct puffs_cn pcn;
if (pops->puffs_node_remove == NULL) {
error = 0;
break;
}
pcn.pcn_pkcnp = &auxt->pvnr_cn;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_remove(pu,
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
opcookie, auxt->pvnr_cookie_targ, &pcn);
break;
}
case PUFFS_VN_LINK:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_link *auxt = auxbuf;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
struct puffs_cn pcn;
if (pops->puffs_node_link == NULL) {
error = 0;
break;
}
pcn.pcn_pkcnp = &auxt->pvnr_cn;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (buildpath) {
error = puffs_path_pcnbuild(pu, &pcn, opcookie);
if (error)
break;
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_link(pu,
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
opcookie, auxt->pvnr_cookie_targ, &pcn);
if (buildpath)
pu->pu_pathfree(pu, &pcn.pcn_po_full);
break;
}
case PUFFS_VN_RENAME:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_rename *auxt = auxbuf;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
struct puffs_cn pcn_src, pcn_targ;
struct puffs_node *pn_src;
if (pops->puffs_node_rename == NULL) {
error = 0;
break;
}
pcn_src.pcn_pkcnp = &auxt->pvnr_cn_src;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_KCREDTOCRED(pcn_src.pcn_cred,
&auxt->pvnr_cn_src_cred);
Instead of supplying a plain pid, supply an abstract struct puffs_cid *, which can currently be used to query the pid and lwpid.
2007-07-01 21:22:13 +04:00
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
pcn_targ.pcn_pkcnp = &auxt->pvnr_cn_targ;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_KCREDTOCRED(pcn_targ.pcn_cred,
&auxt->pvnr_cn_targ_cred);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (buildpath) {
pn_src = auxt->pvnr_cookie_src;
pcn_src.pcn_po_full = pn_src->pn_po;
error = puffs_path_pcnbuild(pu, &pcn_targ,
auxt->pvnr_cookie_targdir);
if (error)
break;
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_rename(pu,
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
opcookie, auxt->pvnr_cookie_src,
&pcn_src, auxt->pvnr_cookie_targdir,
auxt->pvnr_cookie_targ, &pcn_targ);
if (buildpath) {
if (error) {
pu->pu_pathfree(pu,
&pcn_targ.pcn_po_full);
} else {
struct puffs_pathinfo pi;
struct puffs_pathobj po_old;
/* handle this node */
po_old = pn_src->pn_po;
pn_src->pn_po = pcn_targ.pcn_po_full;
if (pn_src->pn_va.va_type != VDIR) {
pu->pu_pathfree(pu, &po_old);
break;
}
/* handle all child nodes for DIRs */
pi.pi_old = &pcn_src.pcn_po_full;
pi.pi_new = &pcn_targ.pcn_po_full;
Sprinkle some hackish locks here and there, just enough to allow libp2k & rump to run multithreaded.
2007-10-29 18:52:44 +03:00
PU_LOCK();
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (puffs_pn_nodewalk(pu,
puffs_path_prefixadj, &pi) != NULL)
error = ENOMEM;
Sprinkle some hackish locks here and there, just enough to allow libp2k & rump to run multithreaded.
2007-10-29 18:52:44 +03:00
PU_UNLOCK();
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
pu->pu_pathfree(pu, &po_old);
}
}
break;
}
case PUFFS_VN_MKDIR:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_mkdir *auxt = auxbuf;
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
struct puffs_newinfo pni;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
struct puffs_cn pcn;
Fix race condition between (create|mknod|mkdir|symlino) and reclaim, just like we did it between lookup and reclaim.
2012-08-10 12:42:10 +04:00
struct puffs_node *pn = NULL;
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (pops->puffs_node_mkdir == NULL) {
error = 0;
break;
}
pcn.pcn_pkcnp = &auxt->pvnr_cn;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
memset(&pni, 0, sizeof(pni));
pni.pni_cookie = &auxt->pvnr_newnode;
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
pni.pni_va = &auxt->pvnr_va;
pni.pni_va_ttl = &auxt->pvnr_va_ttl;
pni.pni_cn_ttl = &auxt->pvnr_cn_ttl;
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (buildpath) {
error = puffs_path_pcnbuild(pu, &pcn, opcookie);
if (error)
break;
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_mkdir(pu,
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
opcookie, &pni, &pcn, &auxt->pvnr_va);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (buildpath) {
if (error) {
pu->pu_pathfree(pu, &pcn.pcn_po_full);
} else {
pn = PU_CMAP(pu, auxt->pvnr_newnode);
pn->pn_po = pcn.pcn_po_full;
}
}
Fix regression that has been introduced when the lookup/reclaim race condition was addressed in libpuffs by counting lookups. The fix assumes that cookies map to struct puffs_cookie, which has not been documented as a requirement for filesystems using libpuffs. As an example, we got burnt by this assumption in libp2k (kern/46734), and we fixed bit by actually mapping libp2k cookies to struct puffs_node. It is unlikely, but there may be third party filesystems that use cookies unmapped to struct puffs_node, and they were left broken for now. - we introduce a puffs_init() flag PUFFS_FLAG_PNCOOKIE that let filesystems inform libpuffs that they map cookies to struct puffs_node. Is that flag is used, the lookup/reclaim race condition fix is enabled. We enable the flag for libp2k. - filesystems that use puffs_pn_new() obviouslty use struct puffs_node and gain PUFFS_FLAG_PNCOOKIE automatically even if they did not specify it in puffs_init(). This include all our PUFFS filesystem in-tree except libp2k. - for filesystems not willing to use struct puffs_node, we introduce a reclaim2 vnop, which is reclaim with an additionnal lookup count argument. This vnop let the filesystem implement the lookup/reclaim race fix on its own.
2012-08-16 13:25:43 +04:00
if (pncookie && !error) {
Fix race condition between (create|mknod|mkdir|symlino) and reclaim, just like we did it between lookup and reclaim.
2012-08-10 12:42:10 +04:00
if (pn == NULL)
pn = PU_CMAP(pu, auxt->pvnr_newnode);
pn->pn_nlookup++;
}
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VN_RMDIR:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_rmdir *auxt = auxbuf;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
struct puffs_cn pcn;
if (pops->puffs_node_rmdir == NULL) {
error = 0;
break;
}
pcn.pcn_pkcnp = &auxt->pvnr_cn;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_rmdir(pu,
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
opcookie, auxt->pvnr_cookie_targ, &pcn);
break;
}
case PUFFS_VN_SYMLINK:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_symlink *auxt = auxbuf;
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
struct puffs_newinfo pni;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
struct puffs_cn pcn;
Fix race condition between (create|mknod|mkdir|symlino) and reclaim, just like we did it between lookup and reclaim.
2012-08-10 12:42:10 +04:00
struct puffs_node *pn = NULL;
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (pops->puffs_node_symlink == NULL) {
error = 0;
break;
}
pcn.pcn_pkcnp = &auxt->pvnr_cn;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
memset(&pni, 0, sizeof(pni));
pni.pni_cookie = &auxt->pvnr_newnode;
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
pni.pni_va = &auxt->pvnr_va;
pni.pni_va_ttl = &auxt->pvnr_va_ttl;
pni.pni_cn_ttl = &auxt->pvnr_cn_ttl;
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (buildpath) {
error = puffs_path_pcnbuild(pu, &pcn, opcookie);
if (error)
break;
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_symlink(pu,
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
opcookie, &pni, &pcn,
&auxt->pvnr_va, auxt->pvnr_link);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (buildpath) {
if (error) {
pu->pu_pathfree(pu, &pcn.pcn_po_full);
} else {
pn = PU_CMAP(pu, auxt->pvnr_newnode);
pn->pn_po = pcn.pcn_po_full;
}
}
Fix regression that has been introduced when the lookup/reclaim race condition was addressed in libpuffs by counting lookups. The fix assumes that cookies map to struct puffs_cookie, which has not been documented as a requirement for filesystems using libpuffs. As an example, we got burnt by this assumption in libp2k (kern/46734), and we fixed bit by actually mapping libp2k cookies to struct puffs_node. It is unlikely, but there may be third party filesystems that use cookies unmapped to struct puffs_node, and they were left broken for now. - we introduce a puffs_init() flag PUFFS_FLAG_PNCOOKIE that let filesystems inform libpuffs that they map cookies to struct puffs_node. Is that flag is used, the lookup/reclaim race condition fix is enabled. We enable the flag for libp2k. - filesystems that use puffs_pn_new() obviouslty use struct puffs_node and gain PUFFS_FLAG_PNCOOKIE automatically even if they did not specify it in puffs_init(). This include all our PUFFS filesystem in-tree except libp2k. - for filesystems not willing to use struct puffs_node, we introduce a reclaim2 vnop, which is reclaim with an additionnal lookup count argument. This vnop let the filesystem implement the lookup/reclaim race fix on its own.
2012-08-16 13:25:43 +04:00
if (pncookie && !error) {
Fix race condition between (create|mknod|mkdir|symlino) and reclaim, just like we did it between lookup and reclaim.
2012-08-10 12:42:10 +04:00
if (pn == NULL)
pn = PU_CMAP(pu, auxt->pvnr_newnode);
pn->pn_nlookup++;
}
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VN_READDIR:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_readdir *auxt = auxbuf;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
struct dirent *dent;
off_t *cookies;
size_t res, origcookies;
if (pops->puffs_node_readdir == NULL) {
error = 0;
break;
}
if (auxt->pvnr_ncookies) {
/* LINTED: pvnr_data is __aligned() */
cookies = (off_t *)auxt->pvnr_data;
origcookies = auxt->pvnr_ncookies;
} else {
cookies = NULL;
origcookies = 0;
}
/* LINTED: dentoff is aligned in the kernel */
dent = (struct dirent *)
(auxt->pvnr_data + auxt->pvnr_dentoff);
res = auxt->pvnr_resid;
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_readdir(pu,
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
opcookie, dent, &auxt->pvnr_offset,
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
&auxt->pvnr_resid, pcr, &auxt->pvnr_eofflag,
cookies, &auxt->pvnr_ncookies);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
/* much easier to track non-working NFS */
assert(auxt->pvnr_ncookies <= origcookies);
/* need to move a bit more */
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
preq->preq_buflen = sizeof(struct puffs_vnmsg_readdir)
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
+ auxt->pvnr_dentoff + (res - auxt->pvnr_resid);
break;
}
case PUFFS_VN_READLINK:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_readlink *auxt = auxbuf;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (pops->puffs_node_readlink == NULL) {
error = EOPNOTSUPP;
break;
}
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
/*LINTED*/
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_readlink(pu, opcookie, pcr,
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
auxt->pvnr_link, &auxt->pvnr_linklen);
break;
}
case PUFFS_VN_RECLAIM:
{
- Improve PUFFS_KFLAG_CACHE_FS_TTL by reclaiming older inactive nodes. The normal kernel behavior is to retain inactive nodes in the freelist until it runs out of vnodes. This has some merit for local filesystems, where the cost of an allocation is about the same as the cost of a lookup. But that situation is not true for distributed filesystems. On the other hand, keeping inactive nodes for a long time hold memory in the file server process, and when the kernel runs out of vnodes, it produce reclaim avalanches that increase lattency for other operations. We do not reclaim inactive vnodes immediatly either, as they may be looked up again shortly. Instead we introduce a grace time and we reclaim nodes that have been inactive beyond the grace time. - Fix lookup/reclaim race condition. The above improvement undercovered a race condition between lookup and reclaim. If we reclaimed a vnode associated with a userland cookie while a lookup returning that same cookiewas inprogress, then the kernel ends up with a vnode associated with a cookie that has been reclaimed in userland. Next operation on the cookie will crash (or at least confuse) the filesystem. We fix this by introducing a lookup count in kernel and userland. On reclaim, the kernel sends the count, which enable userland to detect situation where it initiated a lookup that is not completed in kernel. In such a situation, the reclaim must be ignored, as the node is about to be looked up again.
2012-07-21 09:17:10 +04:00
struct puffs_vnmsg_reclaim *auxt = auxbuf;
struct puffs_node *pn;
Fix regression that has been introduced when the lookup/reclaim race condition was addressed in libpuffs by counting lookups. The fix assumes that cookies map to struct puffs_cookie, which has not been documented as a requirement for filesystems using libpuffs. As an example, we got burnt by this assumption in libp2k (kern/46734), and we fixed bit by actually mapping libp2k cookies to struct puffs_node. It is unlikely, but there may be third party filesystems that use cookies unmapped to struct puffs_node, and they were left broken for now. - we introduce a puffs_init() flag PUFFS_FLAG_PNCOOKIE that let filesystems inform libpuffs that they map cookies to struct puffs_node. Is that flag is used, the lookup/reclaim race condition fix is enabled. We enable the flag for libp2k. - filesystems that use puffs_pn_new() obviouslty use struct puffs_node and gain PUFFS_FLAG_PNCOOKIE automatically even if they did not specify it in puffs_init(). This include all our PUFFS filesystem in-tree except libp2k. - for filesystems not willing to use struct puffs_node, we introduce a reclaim2 vnop, which is reclaim with an additionnal lookup count argument. This vnop let the filesystem implement the lookup/reclaim race fix on its own.
2012-08-16 13:25:43 +04:00
if (pops->puffs_node_reclaim2 != NULL) {
error = pops->puffs_node_reclaim2(pu, opcookie,
auxt->pvnr_nlookup);
break;
}
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (pops->puffs_node_reclaim == NULL) {
error = 0;
break;
}
- Improve PUFFS_KFLAG_CACHE_FS_TTL by reclaiming older inactive nodes. The normal kernel behavior is to retain inactive nodes in the freelist until it runs out of vnodes. This has some merit for local filesystems, where the cost of an allocation is about the same as the cost of a lookup. But that situation is not true for distributed filesystems. On the other hand, keeping inactive nodes for a long time hold memory in the file server process, and when the kernel runs out of vnodes, it produce reclaim avalanches that increase lattency for other operations. We do not reclaim inactive vnodes immediatly either, as they may be looked up again shortly. Instead we introduce a grace time and we reclaim nodes that have been inactive beyond the grace time. - Fix lookup/reclaim race condition. The above improvement undercovered a race condition between lookup and reclaim. If we reclaimed a vnode associated with a userland cookie while a lookup returning that same cookiewas inprogress, then the kernel ends up with a vnode associated with a cookie that has been reclaimed in userland. Next operation on the cookie will crash (or at least confuse) the filesystem. We fix this by introducing a lookup count in kernel and userland. On reclaim, the kernel sends the count, which enable userland to detect situation where it initiated a lookup that is not completed in kernel. In such a situation, the reclaim must be ignored, as the node is about to be looked up again.
2012-07-21 09:17:10 +04:00
/*
* This fixes a race condition,
* where a node in reclaimed by kernel
* after a lookup request is sent,
* but before the reply, leaving the kernel
* with a invalid vnode/cookie reference.
*/
Fix regression that has been introduced when the lookup/reclaim race condition was addressed in libpuffs by counting lookups. The fix assumes that cookies map to struct puffs_cookie, which has not been documented as a requirement for filesystems using libpuffs. As an example, we got burnt by this assumption in libp2k (kern/46734), and we fixed bit by actually mapping libp2k cookies to struct puffs_node. It is unlikely, but there may be third party filesystems that use cookies unmapped to struct puffs_node, and they were left broken for now. - we introduce a puffs_init() flag PUFFS_FLAG_PNCOOKIE that let filesystems inform libpuffs that they map cookies to struct puffs_node. Is that flag is used, the lookup/reclaim race condition fix is enabled. We enable the flag for libp2k. - filesystems that use puffs_pn_new() obviouslty use struct puffs_node and gain PUFFS_FLAG_PNCOOKIE automatically even if they did not specify it in puffs_init(). This include all our PUFFS filesystem in-tree except libp2k. - for filesystems not willing to use struct puffs_node, we introduce a reclaim2 vnop, which is reclaim with an additionnal lookup count argument. This vnop let the filesystem implement the lookup/reclaim race fix on its own.
2012-08-16 13:25:43 +04:00
if (pncookie) {
pn = PU_CMAP(pu, opcookie);
pn->pn_nlookup -= auxt->pvnr_nlookup;
if (pn->pn_nlookup >= 1) {
error = 0;
break;
}
- Improve PUFFS_KFLAG_CACHE_FS_TTL by reclaiming older inactive nodes. The normal kernel behavior is to retain inactive nodes in the freelist until it runs out of vnodes. This has some merit for local filesystems, where the cost of an allocation is about the same as the cost of a lookup. But that situation is not true for distributed filesystems. On the other hand, keeping inactive nodes for a long time hold memory in the file server process, and when the kernel runs out of vnodes, it produce reclaim avalanches that increase lattency for other operations. We do not reclaim inactive vnodes immediatly either, as they may be looked up again shortly. Instead we introduce a grace time and we reclaim nodes that have been inactive beyond the grace time. - Fix lookup/reclaim race condition. The above improvement undercovered a race condition between lookup and reclaim. If we reclaimed a vnode associated with a userland cookie while a lookup returning that same cookiewas inprogress, then the kernel ends up with a vnode associated with a cookie that has been reclaimed in userland. Next operation on the cookie will crash (or at least confuse) the filesystem. We fix this by introducing a lookup count in kernel and userland. On reclaim, the kernel sends the count, which enable userland to detect situation where it initiated a lookup that is not completed in kernel. In such a situation, the reclaim must be ignored, as the node is about to be looked up again.
2012-07-21 09:17:10 +04:00
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_reclaim(pu, opcookie);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VN_INACTIVE:
{
Instead of supplying a plain pid, supply an abstract struct puffs_cid *, which can currently be used to query the pid and lwpid.
2007-07-01 21:22:13 +04:00
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (pops->puffs_node_inactive == NULL) {
error = EOPNOTSUPP;
break;
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_inactive(pu, opcookie);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
case PUFFS_VN_PATHCONF:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_pathconf *auxt = auxbuf;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (pops->puffs_node_pathconf == NULL) {
error = 0;
break;
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_pathconf(pu,
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
opcookie, auxt->pvnr_name,
&auxt->pvnr_retval);
break;
}
case PUFFS_VN_ADVLOCK:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_advlock *auxt = auxbuf;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
if (pops->puffs_node_advlock == NULL) {
error = 0;
break;
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_advlock(pu,
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
opcookie, auxt->pvnr_id, auxt->pvnr_op,
&auxt->pvnr_fl, auxt->pvnr_flags);
break;
}
case PUFFS_VN_PRINT:
{
if (pops->puffs_node_print == NULL) {
error = 0;
break;
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_print(pu,
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
opcookie);
break;
}
Dispatch puffs_node_abortop(). Note: We use the storage of puffs_cache_write from puffs_ops for this purpose. It's not issued by the kernel and hence currently unused, and this saves us from the trouble of bumping the lib major version.
2009-10-18 03:19:52 +04:00
case PUFFS_VN_ABORTOP:
{
struct puffs_vnmsg_abortop *auxt = auxbuf;
struct puffs_cn pcn;
if (pops->puffs_node_abortop == NULL) {
error = 0;
break;
}
pcn.pcn_pkcnp = &auxt->pvnr_cn;
PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
error = pops->puffs_node_abortop(pu, opcookie, &pcn);
break;
}
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
case PUFFS_VN_READ:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_read *auxt = auxbuf;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
size_t res;
if (pops->puffs_node_read == NULL) {
error = EIO;
break;
}
res = auxt->pvnr_resid;
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_read(pu,
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
opcookie, auxt->pvnr_data,
auxt->pvnr_offset, &auxt->pvnr_resid,
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
pcr, auxt->pvnr_ioflag);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
/* need to move a bit more */
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
preq->preq_buflen = sizeof(struct puffs_vnmsg_read)
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
+ (res - auxt->pvnr_resid);
break;
}
case PUFFS_VN_WRITE:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_write *auxt = auxbuf;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
Pass the FAF flag to handlers: - setattr_ttl is updated to add a flag argument. Since it was not present in a previous release, we can change its API - write2 is introduced, this is write with an extra flag for FAF. - fsync already has the FAF information in a flag and needs no change - for other operations, FAF is unconditional
2012-06-27 17:25:23 +04:00
if (pops->puffs_node_write2 != NULL) {
int xflag = 0;
if (!PUFFSOP_WANTREPLY(preq->preq_opclass))
xflag |= PUFFS_SETATTR_FAF;
error = pops->puffs_node_write2(pu,
opcookie, auxt->pvnr_data,
auxt->pvnr_offset, &auxt->pvnr_resid,
pcr, auxt->pvnr_ioflag, xflag);
} else if (pops->puffs_node_write != NULL) {
error = pops->puffs_node_write(pu,
opcookie, auxt->pvnr_data,
auxt->pvnr_offset, &auxt->pvnr_resid,
pcr, auxt->pvnr_ioflag);
} else {
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
error = EIO;
break;
}
/* don't need to move data back to the kernel */
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
preq->preq_buflen = sizeof(struct puffs_vnmsg_write);
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
break;
}
dispatch PUFFS_VN_POLL
2007-05-18 17:53:54 +04:00
case PUFFS_VN_POLL:
{
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_vnmsg_poll *auxt = auxbuf;
Instead of supplying a plain pid, supply an abstract struct puffs_cid *, which can currently be used to query the pid and lwpid.
2007-07-01 21:22:13 +04:00
dispatch PUFFS_VN_POLL
2007-05-18 17:53:54 +04:00
if (pops->puffs_node_poll == NULL) {
error = 0;
/* emulate genfs_poll() */
auxt->pvnr_events &= (POLLIN | POLLOUT
| POLLRDNORM | POLLWRNORM);
break;
}
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
error = pops->puffs_node_poll(pu,
Remove "puffs_cid" from the puffs interface following l-removal from the kernel vfs interfaces. puffs_cc_getcaller(pcc) can be used now should the same information be desired.
2007-11-27 14:31:17 +03:00
opcookie, &auxt->pvnr_events);
dispatch PUFFS_VN_POLL
2007-05-18 17:53:54 +04:00
break;
}
* support extended attributes * bump major due to structure growth * add some spare space * remove ABI sillyness
2010-05-21 14:50:52 +04:00
case PUFFS_VN_GETEXTATTR:
{
struct puffs_vnmsg_getextattr *auxt = auxbuf;
PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
size_t res, *resp, *sizep;
uint8_t *data;
if (pops->puffs_node_getextattr == NULL) {
error = EOPNOTSUPP;
break;
}
if (auxt->pvnr_datasize)
sizep = &auxt->pvnr_datasize;
else
sizep = NULL;
res = auxt->pvnr_resid;
if (res > 0) {
data = auxt->pvnr_data;
resp = &auxt->pvnr_resid;
} else {
data = NULL;
resp = NULL;
}
error = pops->puffs_node_getextattr(pu,
opcookie, auxt->pvnr_attrnamespace,
auxt->pvnr_attrname, sizep, data, resp, pcr);
/* need to move a bit more? */
preq->preq_buflen =
sizeof(struct puffs_vnmsg_getextattr)
+ (res - auxt->pvnr_resid);
break;
}
case PUFFS_VN_SETEXTATTR:
{
struct puffs_vnmsg_setextattr *auxt = auxbuf;
PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
size_t *resp;
uint8_t *data;
if (pops->puffs_node_setextattr == NULL) {
error = EOPNOTSUPP;
break;
}
if (auxt->pvnr_resid > 0) {
data = auxt->pvnr_data;
resp = &auxt->pvnr_resid;
} else {
data = NULL;
resp = NULL;
}
error = pops->puffs_node_setextattr(pu,
opcookie, auxt->pvnr_attrnamespace,
auxt->pvnr_attrname, data, resp, pcr);
break;
}
case PUFFS_VN_LISTEXTATTR:
{
struct puffs_vnmsg_listextattr *auxt = auxbuf;
PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
size_t res, *resp, *sizep;
Add a flag to VOP_LISTEXTATTR(9) so that the vnode interface can tell the filesystem in which format extended attribute shall be listed. There are currently two formats: - NUL-terminated strings, used for listxattr(2), this is the default. - one byte length-pprefixed, non NUL-terminated strings, used for extattr_list_file(2), which is obtanined by setting the EXTATTR_LIST_PREFIXLEN flag to VOP_LISTEXTATTR(9) This approach avoid the need for converting the list back and forth, except in libperfuse, since FUSE uses NUL-terminated strings, and the kernel may have requested EXTATTR_LIST_PREFIXLEN.
2011-07-04 12:07:29 +04:00
int flag;
* support extended attributes * bump major due to structure growth * add some spare space * remove ABI sillyness
2010-05-21 14:50:52 +04:00
uint8_t *data;
if (pops->puffs_node_listextattr == NULL) {
error = EOPNOTSUPP;
break;
}
if (auxt->pvnr_datasize)
sizep = &auxt->pvnr_datasize;
else
sizep = NULL;
res = auxt->pvnr_resid;
if (res > 0) {
data = auxt->pvnr_data;
resp = &auxt->pvnr_resid;
} else {
data = NULL;
resp = NULL;
}
res = auxt->pvnr_resid;
Add a flag to VOP_LISTEXTATTR(9) so that the vnode interface can tell the filesystem in which format extended attribute shall be listed. There are currently two formats: - NUL-terminated strings, used for listxattr(2), this is the default. - one byte length-pprefixed, non NUL-terminated strings, used for extattr_list_file(2), which is obtanined by setting the EXTATTR_LIST_PREFIXLEN flag to VOP_LISTEXTATTR(9) This approach avoid the need for converting the list back and forth, except in libperfuse, since FUSE uses NUL-terminated strings, and the kernel may have requested EXTATTR_LIST_PREFIXLEN.
2011-07-04 12:07:29 +04:00
flag = auxt->pvnr_flag;
* support extended attributes * bump major due to structure growth * add some spare space * remove ABI sillyness
2010-05-21 14:50:52 +04:00
error = pops->puffs_node_listextattr(pu,
opcookie, auxt->pvnr_attrnamespace,
Add a flag to VOP_LISTEXTATTR(9) so that the vnode interface can tell the filesystem in which format extended attribute shall be listed. There are currently two formats: - NUL-terminated strings, used for listxattr(2), this is the default. - one byte length-pprefixed, non NUL-terminated strings, used for extattr_list_file(2), which is obtanined by setting the EXTATTR_LIST_PREFIXLEN flag to VOP_LISTEXTATTR(9) This approach avoid the need for converting the list back and forth, except in libperfuse, since FUSE uses NUL-terminated strings, and the kernel may have requested EXTATTR_LIST_PREFIXLEN.
2011-07-04 12:07:29 +04:00
sizep, data, resp, flag, pcr);
* support extended attributes * bump major due to structure growth * add some spare space * remove ABI sillyness
2010-05-21 14:50:52 +04:00
/* need to move a bit more? */
preq->preq_buflen =
sizeof(struct puffs_vnmsg_listextattr)
+ (res - auxt->pvnr_resid);
break;
}
case PUFFS_VN_DELETEEXTATTR:
{
struct puffs_vnmsg_deleteextattr *auxt = auxbuf;
PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
if (pops->puffs_node_deleteextattr == NULL) {
error = EOPNOTSUPP;
break;
}
error = pops->puffs_node_deleteextattr(pu,
opcookie, auxt->pvnr_attrnamespace,
auxt->pvnr_attrname, pcr);
break;
}
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
default:
printf("inval op %d\n", preq->preq_optype);
error = EINVAL;
break;
}
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
Dispatch puffs_node_abortop(). Note: We use the storage of puffs_cache_write from puffs_ops for this purpose. It's not issued by the kernel and hence currently unused, and this saves us from the trouble of bumping the lib major version.
2009-10-18 03:19:52 +04:00
#if 0
/* not issued by kernel currently */
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
} else if (PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_CACHE) {
struct puffs_cacheinfo *pci = (void *)preq;
if (pu->pu_ops.puffs_cache_write) {
pu->pu_ops.puffs_cache_write(pu, preq->preq_cookie,
pci->pcache_nruns, pci->pcache_runs);
}
error = 0;
Dispatch puffs_node_abortop(). Note: We use the storage of puffs_cache_write from puffs_ops for this purpose. It's not issued by the kernel and hence currently unused, and this saves us from the trouble of bumping the lib major version.
2009-10-18 03:19:52 +04:00
#endif
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
} else if (PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_ERROR) {
struct puffs_error *perr = (void *)preq;
pu->pu_errnotify(pu, preq->preq_optype,
perr->perr_error, perr->perr_str, preq->preq_cookie);
error = 0;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
} else {
/*
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
* I guess the kernel sees this one coming also
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
*/
error = EINVAL;
}
Reserve enough memory for ops which return more than they receive.
2008-03-20 18:28:03 +03:00
out:
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
preq->preq_rv = error;
Step 3 and currently final step of a more general purpose event loop: support removal and addition of i/o file descriptors on the fly. * detect closed file descriptors * automatically free waiters of a dead file descriptor * give the file server the possibility to specify a callback which notifies of a dead file descriptor * move loop function to be a property of the mainloop instead of framebuf (doesn't change effective behaviour) * add the possibility to configure a timespec parameter which attempts to call the loop function periodically * move the event loop functions from the puffs_framebuf namespace to puffs_framev to differential between pure memory management functions
2007-05-15 17:44:46 +04:00
Add possibility to set pre- and post callbacks which will be called for all operations before or after executing the specific callback (the api is not be final yet, though).
2007-10-28 21:40:30 +03:00
if (pu->pu_oppost)
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
pu->pu_oppost(pu);
Add possibility to set pre- and post callbacks which will be called for all operations before or after executing the specific callback (the api is not be final yet, though).
2007-10-28 21:40:30 +03:00
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
pcc->pcc_flags |= PCC_DONE;
move puffs request dispatching code into it's own module. no functional change
2007-05-12 01:42:42 +04:00
}
Reference in New Issue Copy Permalink