* [PATCH 1/2] NFS: Test and Free stateid should take a stateid argument
@ 2011-07-11 17:58 bjschuma
2011-07-11 17:58 ` [PATCH 2/2] NFS: Send SIGIO on lost locks bjschuma
0 siblings, 1 reply; 6+ messages in thread
From: bjschuma @ 2011-07-11 17:58 UTC (permalink / raw)
To: Trond.Myklebust; +Cc: linux-nfs, Bryan Schumaker
From: Bryan Schumaker <bjschuma@netapp.com>
Passing the nfs4_state doesn't guarantee that the correct stateid will
be used. The correct stateid can be determined during lock_expired() or
open_expired() and then passed to these functions.
Signed-off-by: Bryan Schumaker <bjschuma@netapp.com>
---
fs/nfs/nfs4proc.c | 31 +++++++++++++++++--------------
1 files changed, 17 insertions(+), 14 deletions(-)
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 93ef776..f37218b 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -81,8 +81,8 @@ static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
struct nfs_fattr *fattr, struct iattr *sattr,
struct nfs4_state *state);
#ifdef CONFIG_NFS_V4_1
-static int nfs41_test_stateid(struct nfs_server *, struct nfs4_state *);
-static int nfs41_free_stateid(struct nfs_server *, struct nfs4_state *);
+static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *);
+static int nfs41_free_stateid(struct nfs_server *, nfs4_stateid *);
#endif
/* Prevent leaks of NFSv4 errors into userland */
static int nfs4_map_errors(int err)
@@ -1696,10 +1696,10 @@ static int nfs41_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *st
int status;
struct nfs_server *server = NFS_SERVER(state->inode);
- status = nfs41_test_stateid(server, state);
+ status = nfs41_test_stateid(server, &state->open_stateid);
if (status == NFS_OK)
return 0;
- nfs41_free_stateid(server, state);
+ nfs41_free_stateid(server, &state->open_stateid);
return nfs4_open_expired(sp, state);
}
#endif
@@ -4466,11 +4466,14 @@ static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *reques
{
int status;
struct nfs_server *server = NFS_SERVER(state->inode);
+ struct nfs4_lock_state *lock_state = request->fl_u.nfs4_fl.owner;
+ nfs4_stateid *stateid = &lock_state->ls_stateid;
- status = nfs41_test_stateid(server, state);
+ status = nfs41_test_stateid(server, stateid);
if (status == NFS_OK)
return 0;
- nfs41_free_stateid(server, state);
+ nfs41_free_stateid(server, stateid);
+ lock_state->ls_seqid.flags &= !NFS_SEQID_CONFIRMED;
return nfs4_lock_expired(state, request);
}
#endif
@@ -6046,11 +6049,11 @@ out_freepage:
out:
return err;
}
-static int _nfs41_test_stateid(struct nfs_server *server, struct nfs4_state *state)
+static int _nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
{
int status;
struct nfs41_test_stateid_args args = {
- .stateid = &state->stateid,
+ .stateid = stateid,
};
struct nfs41_test_stateid_res res;
struct rpc_message msg = {
@@ -6063,23 +6066,23 @@ static int _nfs41_test_stateid(struct nfs_server *server, struct nfs4_state *sta
return status;
}
-static int nfs41_test_stateid(struct nfs_server *server, struct nfs4_state *state)
+static int nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
{
struct nfs4_exception exception = { };
int err;
do {
err = nfs4_handle_exception(server,
- _nfs41_test_stateid(server, state),
+ _nfs41_test_stateid(server, stateid),
&exception);
} while (exception.retry);
return err;
}
-static int _nfs4_free_stateid(struct nfs_server *server, struct nfs4_state *state)
+static int _nfs4_free_stateid(struct nfs_server *server, nfs4_stateid *stateid)
{
int status;
struct nfs41_free_stateid_args args = {
- .stateid = &state->stateid,
+ .stateid = stateid,
};
struct nfs41_free_stateid_res res;
struct rpc_message msg = {
@@ -6093,13 +6096,13 @@ static int _nfs4_free_stateid(struct nfs_server *server, struct nfs4_state *stat
return status;
}
-static int nfs41_free_stateid(struct nfs_server *server, struct nfs4_state *state)
+static int nfs41_free_stateid(struct nfs_server *server, nfs4_stateid *stateid)
{
struct nfs4_exception exception = { };
int err;
do {
err = nfs4_handle_exception(server,
- _nfs4_free_stateid(server, state),
+ _nfs4_free_stateid(server, stateid),
&exception);
} while (exception.retry);
return err;
--
1.7.6
^ permalink raw reply related [flat|nested] 6+ messages in thread
* [PATCH 2/2] NFS: Send SIGIO on lost locks
2011-07-11 17:58 [PATCH 1/2] NFS: Test and Free stateid should take a stateid argument bjschuma
@ 2011-07-11 17:58 ` bjschuma
2011-07-11 20:08 ` Jeff Layton
0 siblings, 1 reply; 6+ messages in thread
From: bjschuma @ 2011-07-11 17:58 UTC (permalink / raw)
To: Trond.Myklebust; +Cc: linux-nfs, Bryan Schumaker
From: Bryan Schumaker <bjschuma@netapp.com>
If the client loses a lock, we send SIGIO to the application to notify
it. The application can then handle the error from there.
Signed-off-by: Bryan Schumaker <bjschuma@netapp.com>
---
Documentation/kernel-parameters.txt | 7 +++++++
fs/nfs/nfs4_fs.h | 2 ++
fs/nfs/nfs4proc.c | 13 +++++++++++++
fs/nfs/nfs4state.c | 14 ++++++++++++++
fs/nfs/write.c | 7 +++++++
5 files changed, 43 insertions(+), 0 deletions(-)
diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index fd248a31..988ebdc 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -1593,6 +1593,13 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
of returning the full 64-bit number.
The default is to return 64-bit inode numbers.
+ nfs.enable_sigio=
+ [NFSv4.1] enable sending SIGIO to applications.
+ If true, the NFS client will send SIGIO to applications
+ when a lost file lock is detected. If false, the client
+ will attempt to recover the lock.
+ The default is to send SIGIO.
+
nfs.nfs4_disable_idmapping=
[NFSv4] When set, this option disables the NFSv4
idmapper on the client, but only if the mount
diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index c30aed2..8fa02af 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -163,6 +163,7 @@ struct nfs4_lock_state {
struct list_head ls_locks; /* Other lock stateids */
struct nfs4_state * ls_state; /* Pointer to open state */
#define NFS_LOCK_INITIALIZED 1
+#define NFS_LOCK_INVALID 2
int ls_flags;
struct nfs_seqid_counter ls_seqid;
struct rpc_sequence ls_sequence;
@@ -346,6 +347,7 @@ extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state
extern void nfs4_put_open_state(struct nfs4_state *);
extern void nfs4_close_state(struct path *, struct nfs4_state *, fmode_t);
extern void nfs4_close_sync(struct path *, struct nfs4_state *, fmode_t);
+extern int nfs4_validate_lock_stateid(struct nfs4_state *, struct nfs_lock_context *);
extern void nfs4_state_set_mode_locked(struct nfs4_state *, fmode_t);
extern void nfs4_schedule_lease_recovery(struct nfs_client *);
extern void nfs4_schedule_state_manager(struct nfs_client *);
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index f37218b..8757dbd 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -4462,6 +4462,8 @@ out:
}
#if defined(CONFIG_NFS_V4_1)
+bool enable_sigio = true;
+
static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *request)
{
int status;
@@ -4472,10 +4474,21 @@ static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *reques
status = nfs41_test_stateid(server, stateid);
if (status == NFS_OK)
return 0;
+
nfs41_free_stateid(server, stateid);
lock_state->ls_seqid.flags &= !NFS_SEQID_CONFIRMED;
+
+ if (enable_sigio) {
+ lock_state->ls_flags |= NFS_LOCK_INVALID;
+ kill_pid(request->fl_nspid, SIGIO, 1);
+ return 0;
+ }
return nfs4_lock_expired(state, request);
}
+
+module_param(enable_sigio, bool, 0644);
+MODULE_PARM_DESC(enable_sigio, "Send SIGIO to an application when a lost lock"
+ "is detected instead of attempting recovery");
#endif
static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 5d744a5..101d9b4 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -725,6 +725,20 @@ __nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_p
return NULL;
}
+int nfs4_validate_lock_stateid(struct nfs4_state *state, struct nfs_lock_context *lock_ctx)
+{
+ int valid = 1;
+ struct nfs4_lock_state *lock_state;
+
+ spin_lock(&state->state_lock);
+ lock_state = __nfs4_find_lock_state(state, lock_ctx->lockowner, lock_ctx->pid, NFS4_ANY_LOCK_TYPE);
+ if (lock_state != NULL)
+ valid = (lock_state->ls_flags & NFS_LOCK_INVALID) == 0;
+ spin_unlock(&state->state_lock);
+ nfs4_put_lock_state(lock_state);
+ return valid;
+}
+
/*
* Return a compatible lock_state. If no initialized lock_state structure
* exists, return an uninitialized one.
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 7f8732e..49ca975 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -1114,7 +1114,14 @@ out:
void nfs_write_prepare(struct rpc_task *task, void *calldata)
{
struct nfs_write_data *data = calldata;
+ struct nfs4_state *state = data->args.context->state;
+ struct nfs_lock_context *lock_context = data->args.lock_context;
+ if (!nfs4_validate_lock_stateid(state, lock_context)) {
+ task->tk_status = -EIO;
+ task->tk_action = NULL;
+ return;
+ }
if (nfs4_setup_sequence(NFS_SERVER(data->inode),
&data->args.seq_args,
&data->res.seq_res, 1, task))
--
1.7.6
^ permalink raw reply related [flat|nested] 6+ messages in thread
* Re: [PATCH 2/2] NFS: Send SIGIO on lost locks
2011-07-11 17:58 ` [PATCH 2/2] NFS: Send SIGIO on lost locks bjschuma
@ 2011-07-11 20:08 ` Jeff Layton
2011-07-11 20:12 ` Trond Myklebust
0 siblings, 1 reply; 6+ messages in thread
From: Jeff Layton @ 2011-07-11 20:08 UTC (permalink / raw)
To: bjschuma; +Cc: Trond.Myklebust, linux-nfs
On Mon, 11 Jul 2011 13:58:30 -0400
bjschuma@netapp.com wrote:
> From: Bryan Schumaker <bjschuma@netapp.com>
>
> If the client loses a lock, we send SIGIO to the application to notify
> it. The application can then handle the error from there.
>
> Signed-off-by: Bryan Schumaker <bjschuma@netapp.com>
Would SIGLOST be a better choice? Linux hasn't supported that
historically, but we could add it.
> ---
> Documentation/kernel-parameters.txt | 7 +++++++
> fs/nfs/nfs4_fs.h | 2 ++
> fs/nfs/nfs4proc.c | 13 +++++++++++++
> fs/nfs/nfs4state.c | 14 ++++++++++++++
> fs/nfs/write.c | 7 +++++++
> 5 files changed, 43 insertions(+), 0 deletions(-)
>
> diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
> index fd248a31..988ebdc 100644
> --- a/Documentation/kernel-parameters.txt
> +++ b/Documentation/kernel-parameters.txt
> @@ -1593,6 +1593,13 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
> of returning the full 64-bit number.
> The default is to return 64-bit inode numbers.
>
> + nfs.enable_sigio=
> + [NFSv4.1] enable sending SIGIO to applications.
> + If true, the NFS client will send SIGIO to applications
> + when a lost file lock is detected. If false, the client
> + will attempt to recover the lock.
> + The default is to send SIGIO.
> +
> nfs.nfs4_disable_idmapping=
> [NFSv4] When set, this option disables the NFSv4
> idmapper on the client, but only if the mount
> diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
> index c30aed2..8fa02af 100644
> --- a/fs/nfs/nfs4_fs.h
> +++ b/fs/nfs/nfs4_fs.h
> @@ -163,6 +163,7 @@ struct nfs4_lock_state {
> struct list_head ls_locks; /* Other lock stateids */
> struct nfs4_state * ls_state; /* Pointer to open state */
> #define NFS_LOCK_INITIALIZED 1
> +#define NFS_LOCK_INVALID 2
> int ls_flags;
> struct nfs_seqid_counter ls_seqid;
> struct rpc_sequence ls_sequence;
> @@ -346,6 +347,7 @@ extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state
> extern void nfs4_put_open_state(struct nfs4_state *);
> extern void nfs4_close_state(struct path *, struct nfs4_state *, fmode_t);
> extern void nfs4_close_sync(struct path *, struct nfs4_state *, fmode_t);
> +extern int nfs4_validate_lock_stateid(struct nfs4_state *, struct nfs_lock_context *);
> extern void nfs4_state_set_mode_locked(struct nfs4_state *, fmode_t);
> extern void nfs4_schedule_lease_recovery(struct nfs_client *);
> extern void nfs4_schedule_state_manager(struct nfs_client *);
> diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
> index f37218b..8757dbd 100644
> --- a/fs/nfs/nfs4proc.c
> +++ b/fs/nfs/nfs4proc.c
> @@ -4462,6 +4462,8 @@ out:
> }
>
> #if defined(CONFIG_NFS_V4_1)
> +bool enable_sigio = true;
> +
> static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *request)
> {
> int status;
> @@ -4472,10 +4474,21 @@ static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *reques
> status = nfs41_test_stateid(server, stateid);
> if (status == NFS_OK)
> return 0;
> +
> nfs41_free_stateid(server, stateid);
> lock_state->ls_seqid.flags &= !NFS_SEQID_CONFIRMED;
> +
> + if (enable_sigio) {
> + lock_state->ls_flags |= NFS_LOCK_INVALID;
> + kill_pid(request->fl_nspid, SIGIO, 1);
> + return 0;
> + }
> return nfs4_lock_expired(state, request);
> }
> +
> +module_param(enable_sigio, bool, 0644);
> +MODULE_PARM_DESC(enable_sigio, "Send SIGIO to an application when a lost lock"
> + "is detected instead of attempting recovery");
> #endif
>
> static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
> diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
> index 5d744a5..101d9b4 100644
> --- a/fs/nfs/nfs4state.c
> +++ b/fs/nfs/nfs4state.c
> @@ -725,6 +725,20 @@ __nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_p
> return NULL;
> }
>
> +int nfs4_validate_lock_stateid(struct nfs4_state *state, struct nfs_lock_context *lock_ctx)
> +{
> + int valid = 1;
> + struct nfs4_lock_state *lock_state;
> +
> + spin_lock(&state->state_lock);
> + lock_state = __nfs4_find_lock_state(state, lock_ctx->lockowner, lock_ctx->pid, NFS4_ANY_LOCK_TYPE);
> + if (lock_state != NULL)
> + valid = (lock_state->ls_flags & NFS_LOCK_INVALID) == 0;
> + spin_unlock(&state->state_lock);
> + nfs4_put_lock_state(lock_state);
> + return valid;
> +}
> +
> /*
> * Return a compatible lock_state. If no initialized lock_state structure
> * exists, return an uninitialized one.
> diff --git a/fs/nfs/write.c b/fs/nfs/write.c
> index 7f8732e..49ca975 100644
> --- a/fs/nfs/write.c
> +++ b/fs/nfs/write.c
> @@ -1114,7 +1114,14 @@ out:
> void nfs_write_prepare(struct rpc_task *task, void *calldata)
> {
> struct nfs_write_data *data = calldata;
> + struct nfs4_state *state = data->args.context->state;
> + struct nfs_lock_context *lock_context = data->args.lock_context;
>
> + if (!nfs4_validate_lock_stateid(state, lock_context)) {
> + task->tk_status = -EIO;
> + task->tk_action = NULL;
> + return;
> + }
> if (nfs4_setup_sequence(NFS_SERVER(data->inode),
> &data->args.seq_args,
> &data->res.seq_res, 1, task))
--
Jeff Layton <jlayton@poochiereds.net>
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 2/2] NFS: Send SIGIO on lost locks
2011-07-11 20:08 ` Jeff Layton
@ 2011-07-11 20:12 ` Trond Myklebust
2011-07-12 0:47 ` Jeff Layton
0 siblings, 1 reply; 6+ messages in thread
From: Trond Myklebust @ 2011-07-11 20:12 UTC (permalink / raw)
To: Jeff Layton; +Cc: bjschuma, linux-nfs
On Mon, 2011-07-11 at 16:08 -0400, Jeff Layton wrote:
> On Mon, 11 Jul 2011 13:58:30 -0400
> bjschuma@netapp.com wrote:
>
> > From: Bryan Schumaker <bjschuma@netapp.com>
> >
> > If the client loses a lock, we send SIGIO to the application to notify
> > it. The application can then handle the error from there.
> >
> > Signed-off-by: Bryan Schumaker <bjschuma@netapp.com>
>
> Would SIGLOST be a better choice? Linux hasn't supported that
> historically, but we could add it.
SIGLOST is 'defined' in the kernel as follows:
#define SIGIO 29
#define SIGPOLL SIGIO
/*
#define SIGLOST 29
*/
IOW: it is synonymous with SIGPOLL and SIGIO. This explains Bryan's
choice.
Cheers
Trond
--
Trond Myklebust
Linux NFS client maintainer
NetApp
Trond.Myklebust@netapp.com
www.netapp.com
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 2/2] NFS: Send SIGIO on lost locks
2011-07-11 20:12 ` Trond Myklebust
@ 2011-07-12 0:47 ` Jeff Layton
2011-07-12 2:31 ` Trond Myklebust
0 siblings, 1 reply; 6+ messages in thread
From: Jeff Layton @ 2011-07-12 0:47 UTC (permalink / raw)
To: Trond Myklebust; +Cc: bjschuma, linux-nfs
On Mon, 11 Jul 2011 16:12:24 -0400
Trond Myklebust <Trond.Myklebust@netapp.com> wrote:
> On Mon, 2011-07-11 at 16:08 -0400, Jeff Layton wrote:
> > On Mon, 11 Jul 2011 13:58:30 -0400
> > bjschuma@netapp.com wrote:
> >
> > > From: Bryan Schumaker <bjschuma@netapp.com>
> > >
> > > If the client loses a lock, we send SIGIO to the application to notify
> > > it. The application can then handle the error from there.
> > >
> > > Signed-off-by: Bryan Schumaker <bjschuma@netapp.com>
> >
> > Would SIGLOST be a better choice? Linux hasn't supported that
> > historically, but we could add it.
>
> SIGLOST is 'defined' in the kernel as follows:
>
> #define SIGIO 29
> #define SIGPOLL SIGIO
> /*
> #define SIGLOST 29
> */
>
> IOW: it is synonymous with SIGPOLL and SIGIO. This explains Bryan's
> choice.
>
> Cheers
> Trond
>
Right. I just wonder whether we'd be better off making this a distinct
signal with its own number. It seems like there would be value in being
able to distinguish between SIGLOST and SIGIO.
--
Jeff Layton <jlayton@redhat.com>
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 2/2] NFS: Send SIGIO on lost locks
2011-07-12 0:47 ` Jeff Layton
@ 2011-07-12 2:31 ` Trond Myklebust
0 siblings, 0 replies; 6+ messages in thread
From: Trond Myklebust @ 2011-07-12 2:31 UTC (permalink / raw)
To: Jeff Layton; +Cc: bjschuma, linux-nfs
On Mon, 2011-07-11 at 20:47 -0400, Jeff Layton wrote:
> On Mon, 11 Jul 2011 16:12:24 -0400
> Trond Myklebust <Trond.Myklebust@netapp.com> wrote:
>
> > On Mon, 2011-07-11 at 16:08 -0400, Jeff Layton wrote:
> > > On Mon, 11 Jul 2011 13:58:30 -0400
> > > bjschuma@netapp.com wrote:
> > >
> > > > From: Bryan Schumaker <bjschuma@netapp.com>
> > > >
> > > > If the client loses a lock, we send SIGIO to the application to notify
> > > > it. The application can then handle the error from there.
> > > >
> > > > Signed-off-by: Bryan Schumaker <bjschuma@netapp.com>
> > >
> > > Would SIGLOST be a better choice? Linux hasn't supported that
> > > historically, but we could add it.
> >
> > SIGLOST is 'defined' in the kernel as follows:
> >
> > #define SIGIO 29
> > #define SIGPOLL SIGIO
> > /*
> > #define SIGLOST 29
> > */
> >
> > IOW: it is synonymous with SIGPOLL and SIGIO. This explains Bryan's
> > choice.
> >
> > Cheers
> > Trond
> >
>
> Right. I just wonder whether we'd be better off making this a distinct
> signal with its own number. It seems like there would be value in being
> able to distinguish between SIGLOST and SIGIO.
Actually, I think there is value in distinguishing between SIGIO and
SIGPOLL too, but it would appear that it is a bit late to do that.
Note that we can (and probably should) use a siginfo structure to pass a
bit more info to the application. That would mean filling out a siginfo
and then replacing kill_pid() with kill_pid_info(), but that should be
easily doable and can be made to resolve the above ambiguities.
Cheers
Trond
--
Trond Myklebust
Linux NFS client maintainer
NetApp
Trond.Myklebust@netapp.com
www.netapp.com
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2011-07-12 2:31 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2011-07-11 17:58 [PATCH 1/2] NFS: Test and Free stateid should take a stateid argument bjschuma
2011-07-11 17:58 ` [PATCH 2/2] NFS: Send SIGIO on lost locks bjschuma
2011-07-11 20:08 ` Jeff Layton
2011-07-11 20:12 ` Trond Myklebust
2011-07-12 0:47 ` Jeff Layton
2011-07-12 2:31 ` Trond Myklebust
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).