2006-11-02 09:19:21 -07:00
|
|
|
/******************************************************************************
|
|
|
|
*******************************************************************************
|
|
|
|
**
|
|
|
|
** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
2009-01-28 11:57:40 -07:00
|
|
|
** Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved.
|
2006-11-02 09:19:21 -07:00
|
|
|
**
|
|
|
|
** This copyrighted material is made available to anyone wishing to use,
|
|
|
|
** modify, copy, or redistribute it subject to the terms and conditions
|
|
|
|
** of the GNU General Public License v.2.
|
|
|
|
**
|
|
|
|
*******************************************************************************
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* lowcomms.c
|
|
|
|
*
|
|
|
|
* This is the "low-level" comms layer.
|
|
|
|
*
|
|
|
|
* It is responsible for sending/receiving messages
|
|
|
|
* from other nodes in the cluster.
|
|
|
|
*
|
|
|
|
* Cluster nodes are referred to by their nodeids. nodeids are
|
|
|
|
* simply 32 bit numbers to the locking module - if they need to
|
2009-01-22 14:26:47 -07:00
|
|
|
* be expanded for the cluster infrastructure then that is its
|
2006-11-02 09:19:21 -07:00
|
|
|
* responsibility. It is this layer's
|
|
|
|
* responsibility to resolve these into IP address or
|
|
|
|
* whatever it needs for inter-node communication.
|
|
|
|
*
|
|
|
|
* The comms level is two kernel threads that deal mainly with
|
|
|
|
* the receiving of messages from other nodes and passing them
|
|
|
|
* up to the mid-level comms layer (which understands the
|
|
|
|
* message format) for execution by the locking core, and
|
|
|
|
* a send thread which does all the setting up of connections
|
|
|
|
* to remote nodes and the sending of data. Threads are not allowed
|
|
|
|
* to send their own data because it may cause them to wait in times
|
|
|
|
* of high load. Also, this way, the sending thread can collect together
|
|
|
|
* messages bound for one node and send them in one block.
|
|
|
|
*
|
2009-01-22 14:26:47 -07:00
|
|
|
* lowcomms will choose to use either TCP or SCTP as its transport layer
|
2007-04-17 08:39:57 -06:00
|
|
|
* depending on the configuration variable 'protocol'. This should be set
|
2009-01-22 14:26:47 -07:00
|
|
|
* to 0 (default) for TCP or 1 for SCTP. It should be configured using a
|
2007-04-17 08:39:57 -06:00
|
|
|
* cluster-wide mechanism as it must be the same on all nodes of the cluster
|
|
|
|
* for the DLM to function.
|
2006-11-02 09:19:21 -07:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <asm/ioctls.h>
|
|
|
|
#include <net/sock.h>
|
|
|
|
#include <net/tcp.h>
|
|
|
|
#include <linux/pagemap.h>
|
2007-04-17 08:39:57 -06:00
|
|
|
#include <linux/file.h>
|
2008-05-12 09:04:51 -06:00
|
|
|
#include <linux/mutex.h>
|
2007-04-17 08:39:57 -06:00
|
|
|
#include <linux/sctp.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2012-03-07 22:55:59 -07:00
|
|
|
#include <net/sctp/sctp.h>
|
2007-04-17 08:39:57 -06:00
|
|
|
#include <net/sctp/user.h>
|
2009-01-22 14:24:49 -07:00
|
|
|
#include <net/ipv6.h>
|
2006-11-02 09:19:21 -07:00
|
|
|
|
|
|
|
#include "dlm_internal.h"
|
|
|
|
#include "lowcomms.h"
|
|
|
|
#include "midcomms.h"
|
|
|
|
#include "config.h"
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
#define NEEDED_RMEM (4*1024*1024)
|
2009-01-28 11:57:40 -07:00
|
|
|
#define CONN_HASH_SIZE 32
|
2007-04-17 08:39:57 -06:00
|
|
|
|
2010-11-12 10:15:20 -07:00
|
|
|
/* Number of messages to send before rescheduling */
|
|
|
|
#define MAX_SEND_MSG_COUNT 25
|
|
|
|
|
2006-11-02 09:19:21 -07:00
|
|
|
struct cbuf {
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
unsigned int base;
|
|
|
|
unsigned int len;
|
|
|
|
unsigned int mask;
|
2006-11-02 09:19:21 -07:00
|
|
|
};
|
|
|
|
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
static void cbuf_add(struct cbuf *cb, int n)
|
|
|
|
{
|
|
|
|
cb->len += n;
|
|
|
|
}
|
2006-11-02 09:19:21 -07:00
|
|
|
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
static int cbuf_data(struct cbuf *cb)
|
|
|
|
{
|
|
|
|
return ((cb->base + cb->len) & cb->mask);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void cbuf_init(struct cbuf *cb, int size)
|
|
|
|
{
|
|
|
|
cb->base = cb->len = 0;
|
|
|
|
cb->mask = size-1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void cbuf_eat(struct cbuf *cb, int n)
|
|
|
|
{
|
|
|
|
cb->len -= n;
|
|
|
|
cb->base += n;
|
|
|
|
cb->base &= cb->mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cbuf_empty(struct cbuf *cb)
|
|
|
|
{
|
|
|
|
return cb->len == 0;
|
|
|
|
}
|
2006-11-02 09:19:21 -07:00
|
|
|
|
|
|
|
struct connection {
|
|
|
|
struct socket *sock; /* NULL if not connected */
|
|
|
|
uint32_t nodeid; /* So we know who we are in the list */
|
2007-01-24 04:17:59 -07:00
|
|
|
struct mutex sock_mutex;
|
2007-04-17 08:39:57 -06:00
|
|
|
unsigned long flags;
|
2006-11-02 09:19:21 -07:00
|
|
|
#define CF_READ_PENDING 1
|
|
|
|
#define CF_WRITE_PENDING 2
|
|
|
|
#define CF_CONNECT_PENDING 3
|
2007-04-17 08:39:57 -06:00
|
|
|
#define CF_INIT_PENDING 4
|
|
|
|
#define CF_IS_OTHERCON 5
|
2009-08-11 15:18:23 -06:00
|
|
|
#define CF_CLOSE 6
|
2010-11-10 22:56:39 -07:00
|
|
|
#define CF_APP_LIMITED 7
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
struct list_head writequeue; /* List of outgoing writequeue_entries */
|
2006-11-02 09:19:21 -07:00
|
|
|
spinlock_t writequeue_lock;
|
|
|
|
int (*rx_action) (struct connection *); /* What to do when active */
|
2007-04-17 08:39:57 -06:00
|
|
|
void (*connect_action) (struct connection *); /* What to do to connect */
|
2006-11-02 09:19:21 -07:00
|
|
|
struct page *rx_page;
|
|
|
|
struct cbuf cb;
|
|
|
|
int retries;
|
|
|
|
#define MAX_CONNECT_RETRIES 3
|
2007-04-17 08:39:57 -06:00
|
|
|
int sctp_assoc;
|
2009-01-28 11:57:40 -07:00
|
|
|
struct hlist_node list;
|
2006-11-02 09:19:21 -07:00
|
|
|
struct connection *othercon;
|
2007-01-15 07:33:34 -07:00
|
|
|
struct work_struct rwork; /* Receive workqueue */
|
|
|
|
struct work_struct swork; /* Send workqueue */
|
2006-11-02 09:19:21 -07:00
|
|
|
};
|
|
|
|
#define sock2con(x) ((struct connection *)(x)->sk_user_data)
|
|
|
|
|
|
|
|
/* An entry waiting to be sent */
|
|
|
|
struct writequeue_entry {
|
|
|
|
struct list_head list;
|
|
|
|
struct page *page;
|
|
|
|
int offset;
|
|
|
|
int len;
|
|
|
|
int end;
|
|
|
|
int users;
|
|
|
|
struct connection *con;
|
|
|
|
};
|
|
|
|
|
2012-07-26 11:44:30 -06:00
|
|
|
struct dlm_node_addr {
|
|
|
|
struct list_head list;
|
|
|
|
int nodeid;
|
|
|
|
int addr_count;
|
|
|
|
struct sockaddr_storage *addr[DLM_MAX_ADDR_COUNT];
|
|
|
|
};
|
|
|
|
|
|
|
|
static LIST_HEAD(dlm_node_addrs);
|
|
|
|
static DEFINE_SPINLOCK(dlm_node_addrs_spin);
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
static struct sockaddr_storage *dlm_local_addr[DLM_MAX_ADDR_COUNT];
|
|
|
|
static int dlm_local_count;
|
2012-03-30 10:46:08 -06:00
|
|
|
static int dlm_allow_conn;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2007-01-15 07:33:34 -07:00
|
|
|
/* Work queues */
|
|
|
|
static struct workqueue_struct *recv_workqueue;
|
|
|
|
static struct workqueue_struct *send_workqueue;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2009-01-28 11:57:40 -07:00
|
|
|
static struct hlist_head connection_hash[CONN_HASH_SIZE];
|
2008-05-12 09:04:51 -06:00
|
|
|
static DEFINE_MUTEX(connections_lock);
|
2006-12-08 12:31:12 -07:00
|
|
|
static struct kmem_cache *con_cache;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2007-01-15 07:33:34 -07:00
|
|
|
static void process_recv_sockets(struct work_struct *work);
|
|
|
|
static void process_send_sockets(struct work_struct *work);
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2009-01-28 11:57:40 -07:00
|
|
|
|
|
|
|
/* This is deliberately very simple because most clusters have simple
|
|
|
|
sequential nodeids, so we should be able to go straight to a connection
|
|
|
|
struct in the array */
|
|
|
|
static inline int nodeid_hash(int nodeid)
|
|
|
|
{
|
|
|
|
return nodeid & (CONN_HASH_SIZE-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct connection *__find_con(int nodeid)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
struct hlist_node *h;
|
|
|
|
struct connection *con;
|
|
|
|
|
|
|
|
r = nodeid_hash(nodeid);
|
|
|
|
|
|
|
|
hlist_for_each_entry(con, h, &connection_hash[r], list) {
|
|
|
|
if (con->nodeid == nodeid)
|
|
|
|
return con;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
/*
|
|
|
|
* If 'allocation' is zero then we don't attempt to create a new
|
|
|
|
* connection structure for this node.
|
|
|
|
*/
|
|
|
|
static struct connection *__nodeid2con(int nodeid, gfp_t alloc)
|
2006-11-02 09:19:21 -07:00
|
|
|
{
|
|
|
|
struct connection *con = NULL;
|
2007-04-17 08:39:57 -06:00
|
|
|
int r;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2009-01-28 11:57:40 -07:00
|
|
|
con = __find_con(nodeid);
|
2007-04-17 08:39:57 -06:00
|
|
|
if (con || !alloc)
|
|
|
|
return con;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
con = kmem_cache_zalloc(con_cache, alloc);
|
|
|
|
if (!con)
|
|
|
|
return NULL;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2009-01-28 11:57:40 -07:00
|
|
|
r = nodeid_hash(nodeid);
|
|
|
|
hlist_add_head(&con->list, &connection_hash[r]);
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
con->nodeid = nodeid;
|
|
|
|
mutex_init(&con->sock_mutex);
|
|
|
|
INIT_LIST_HEAD(&con->writequeue);
|
|
|
|
spin_lock_init(&con->writequeue_lock);
|
|
|
|
INIT_WORK(&con->swork, process_send_sockets);
|
|
|
|
INIT_WORK(&con->rwork, process_recv_sockets);
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
/* Setup action pointers for child sockets */
|
|
|
|
if (con->nodeid) {
|
2009-01-28 11:57:40 -07:00
|
|
|
struct connection *zerocon = __find_con(0);
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
con->connect_action = zerocon->connect_action;
|
|
|
|
if (!con->rx_action)
|
|
|
|
con->rx_action = zerocon->rx_action;
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
return con;
|
|
|
|
}
|
|
|
|
|
2009-01-28 11:57:40 -07:00
|
|
|
/* Loop round all connections */
|
|
|
|
static void foreach_conn(void (*conn_func)(struct connection *c))
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct hlist_node *h, *n;
|
|
|
|
struct connection *con;
|
|
|
|
|
|
|
|
for (i = 0; i < CONN_HASH_SIZE; i++) {
|
|
|
|
hlist_for_each_entry_safe(con, h, n, &connection_hash[i], list){
|
|
|
|
conn_func(con);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
static struct connection *nodeid2con(int nodeid, gfp_t allocation)
|
|
|
|
{
|
|
|
|
struct connection *con;
|
|
|
|
|
2008-05-12 09:04:51 -06:00
|
|
|
mutex_lock(&connections_lock);
|
2007-04-17 08:39:57 -06:00
|
|
|
con = __nodeid2con(nodeid, allocation);
|
2008-05-12 09:04:51 -06:00
|
|
|
mutex_unlock(&connections_lock);
|
2007-04-17 08:39:57 -06:00
|
|
|
|
2006-11-02 09:19:21 -07:00
|
|
|
return con;
|
|
|
|
}
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
/* This is a bit drastic, but only called when things go wrong */
|
|
|
|
static struct connection *assoc2con(int assoc_id)
|
|
|
|
{
|
|
|
|
int i;
|
2009-01-28 11:57:40 -07:00
|
|
|
struct hlist_node *h;
|
2007-04-17 08:39:57 -06:00
|
|
|
struct connection *con;
|
|
|
|
|
2008-05-12 09:04:51 -06:00
|
|
|
mutex_lock(&connections_lock);
|
2009-01-28 11:57:40 -07:00
|
|
|
|
|
|
|
for (i = 0 ; i < CONN_HASH_SIZE; i++) {
|
|
|
|
hlist_for_each_entry(con, h, &connection_hash[i], list) {
|
2010-08-03 15:34:16 -06:00
|
|
|
if (con->sctp_assoc == assoc_id) {
|
2009-01-28 11:57:40 -07:00
|
|
|
mutex_unlock(&connections_lock);
|
|
|
|
return con;
|
|
|
|
}
|
2007-04-17 08:39:57 -06:00
|
|
|
}
|
|
|
|
}
|
2008-05-12 09:04:51 -06:00
|
|
|
mutex_unlock(&connections_lock);
|
2007-04-17 08:39:57 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-07-26 11:44:30 -06:00
|
|
|
static struct dlm_node_addr *find_node_addr(int nodeid)
|
|
|
|
{
|
|
|
|
struct dlm_node_addr *na;
|
|
|
|
|
|
|
|
list_for_each_entry(na, &dlm_node_addrs, list) {
|
|
|
|
if (na->nodeid == nodeid)
|
|
|
|
return na;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int addr_compare(struct sockaddr_storage *x, struct sockaddr_storage *y)
|
2007-04-17 08:39:57 -06:00
|
|
|
{
|
2012-07-26 11:44:30 -06:00
|
|
|
switch (x->ss_family) {
|
|
|
|
case AF_INET: {
|
|
|
|
struct sockaddr_in *sinx = (struct sockaddr_in *)x;
|
|
|
|
struct sockaddr_in *siny = (struct sockaddr_in *)y;
|
|
|
|
if (sinx->sin_addr.s_addr != siny->sin_addr.s_addr)
|
|
|
|
return 0;
|
|
|
|
if (sinx->sin_port != siny->sin_port)
|
|
|
|
return 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case AF_INET6: {
|
|
|
|
struct sockaddr_in6 *sinx = (struct sockaddr_in6 *)x;
|
|
|
|
struct sockaddr_in6 *siny = (struct sockaddr_in6 *)y;
|
|
|
|
if (!ipv6_addr_equal(&sinx->sin6_addr, &siny->sin6_addr))
|
|
|
|
return 0;
|
|
|
|
if (sinx->sin6_port != siny->sin6_port)
|
|
|
|
return 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nodeid_to_addr(int nodeid, struct sockaddr_storage *sas_out,
|
|
|
|
struct sockaddr *sa_out)
|
|
|
|
{
|
|
|
|
struct sockaddr_storage sas;
|
|
|
|
struct dlm_node_addr *na;
|
2007-04-17 08:39:57 -06:00
|
|
|
|
|
|
|
if (!dlm_local_count)
|
|
|
|
return -1;
|
|
|
|
|
2012-07-26 11:44:30 -06:00
|
|
|
spin_lock(&dlm_node_addrs_spin);
|
|
|
|
na = find_node_addr(nodeid);
|
|
|
|
if (na && na->addr_count)
|
|
|
|
memcpy(&sas, na->addr[0], sizeof(struct sockaddr_storage));
|
|
|
|
spin_unlock(&dlm_node_addrs_spin);
|
|
|
|
|
|
|
|
if (!na)
|
|
|
|
return -EEXIST;
|
|
|
|
|
|
|
|
if (!na->addr_count)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
if (sas_out)
|
|
|
|
memcpy(sas_out, &sas, sizeof(struct sockaddr_storage));
|
|
|
|
|
|
|
|
if (!sa_out)
|
|
|
|
return 0;
|
2007-04-17 08:39:57 -06:00
|
|
|
|
|
|
|
if (dlm_local_addr[0]->ss_family == AF_INET) {
|
2012-07-26 11:44:30 -06:00
|
|
|
struct sockaddr_in *in4 = (struct sockaddr_in *) &sas;
|
|
|
|
struct sockaddr_in *ret4 = (struct sockaddr_in *) sa_out;
|
2007-04-17 08:39:57 -06:00
|
|
|
ret4->sin_addr.s_addr = in4->sin_addr.s_addr;
|
|
|
|
} else {
|
2012-07-26 11:44:30 -06:00
|
|
|
struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) &sas;
|
|
|
|
struct sockaddr_in6 *ret6 = (struct sockaddr_in6 *) sa_out;
|
2011-11-20 20:39:03 -07:00
|
|
|
ret6->sin6_addr = in6->sin6_addr;
|
2007-04-17 08:39:57 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-07-26 11:44:30 -06:00
|
|
|
static int addr_to_nodeid(struct sockaddr_storage *addr, int *nodeid)
|
|
|
|
{
|
|
|
|
struct dlm_node_addr *na;
|
|
|
|
int rv = -EEXIST;
|
|
|
|
|
|
|
|
spin_lock(&dlm_node_addrs_spin);
|
|
|
|
list_for_each_entry(na, &dlm_node_addrs, list) {
|
|
|
|
if (!na->addr_count)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!addr_compare(na->addr[0], addr))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
*nodeid = na->nodeid;
|
|
|
|
rv = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
spin_unlock(&dlm_node_addrs_spin);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
int dlm_lowcomms_addr(int nodeid, struct sockaddr_storage *addr, int len)
|
|
|
|
{
|
|
|
|
struct sockaddr_storage *new_addr;
|
|
|
|
struct dlm_node_addr *new_node, *na;
|
|
|
|
|
|
|
|
new_node = kzalloc(sizeof(struct dlm_node_addr), GFP_NOFS);
|
|
|
|
if (!new_node)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
new_addr = kzalloc(sizeof(struct sockaddr_storage), GFP_NOFS);
|
|
|
|
if (!new_addr) {
|
|
|
|
kfree(new_node);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(new_addr, addr, len);
|
|
|
|
|
|
|
|
spin_lock(&dlm_node_addrs_spin);
|
|
|
|
na = find_node_addr(nodeid);
|
|
|
|
if (!na) {
|
|
|
|
new_node->nodeid = nodeid;
|
|
|
|
new_node->addr[0] = new_addr;
|
|
|
|
new_node->addr_count = 1;
|
|
|
|
list_add(&new_node->list, &dlm_node_addrs);
|
|
|
|
spin_unlock(&dlm_node_addrs_spin);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (na->addr_count >= DLM_MAX_ADDR_COUNT) {
|
|
|
|
spin_unlock(&dlm_node_addrs_spin);
|
|
|
|
kfree(new_addr);
|
|
|
|
kfree(new_node);
|
|
|
|
return -ENOSPC;
|
|
|
|
}
|
|
|
|
|
|
|
|
na->addr[na->addr_count++] = new_addr;
|
|
|
|
spin_unlock(&dlm_node_addrs_spin);
|
|
|
|
kfree(new_node);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-11-02 09:19:21 -07:00
|
|
|
/* Data available on socket or listen socket received a connect */
|
|
|
|
static void lowcomms_data_ready(struct sock *sk, int count_unused)
|
|
|
|
{
|
|
|
|
struct connection *con = sock2con(sk);
|
2007-06-01 09:07:26 -06:00
|
|
|
if (con && !test_and_set_bit(CF_READ_PENDING, &con->flags))
|
2007-01-15 07:33:34 -07:00
|
|
|
queue_work(recv_workqueue, &con->rwork);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void lowcomms_write_space(struct sock *sk)
|
|
|
|
{
|
|
|
|
struct connection *con = sock2con(sk);
|
|
|
|
|
2010-11-10 22:56:39 -07:00
|
|
|
if (!con)
|
|
|
|
return;
|
|
|
|
|
|
|
|
clear_bit(SOCK_NOSPACE, &con->sock->flags);
|
|
|
|
|
|
|
|
if (test_and_clear_bit(CF_APP_LIMITED, &con->flags)) {
|
|
|
|
con->sock->sk->sk_write_pending--;
|
|
|
|
clear_bit(SOCK_ASYNC_NOSPACE, &con->sock->flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!test_and_set_bit(CF_WRITE_PENDING, &con->flags))
|
2007-01-15 07:33:34 -07:00
|
|
|
queue_work(send_workqueue, &con->swork);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void lowcomms_connect_sock(struct connection *con)
|
|
|
|
{
|
2009-08-11 15:18:23 -06:00
|
|
|
if (test_bit(CF_CLOSE, &con->flags))
|
|
|
|
return;
|
2007-01-15 07:33:34 -07:00
|
|
|
if (!test_and_set_bit(CF_CONNECT_PENDING, &con->flags))
|
|
|
|
queue_work(send_workqueue, &con->swork);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void lowcomms_state_change(struct sock *sk)
|
|
|
|
{
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
if (sk->sk_state == TCP_ESTABLISHED)
|
2006-11-02 09:19:21 -07:00
|
|
|
lowcomms_write_space(sk);
|
|
|
|
}
|
|
|
|
|
2009-05-07 09:54:16 -06:00
|
|
|
int dlm_lowcomms_connect_node(int nodeid)
|
|
|
|
{
|
|
|
|
struct connection *con;
|
|
|
|
|
2009-09-18 13:31:47 -06:00
|
|
|
/* with sctp there's no connecting without sending */
|
|
|
|
if (dlm_config.ci_protocol != 0)
|
|
|
|
return 0;
|
|
|
|
|
2009-05-07 09:54:16 -06:00
|
|
|
if (nodeid == dlm_our_nodeid())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
con = nodeid2con(nodeid, GFP_NOFS);
|
|
|
|
if (!con)
|
|
|
|
return -ENOMEM;
|
|
|
|
lowcomms_connect_sock(con);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-11-02 09:19:21 -07:00
|
|
|
/* Make a socket active */
|
2012-08-10 00:58:42 -06:00
|
|
|
static void add_sock(struct socket *sock, struct connection *con)
|
2006-11-02 09:19:21 -07:00
|
|
|
{
|
|
|
|
con->sock = sock;
|
|
|
|
|
|
|
|
/* Install a data_ready callback */
|
|
|
|
con->sock->sk->sk_data_ready = lowcomms_data_ready;
|
|
|
|
con->sock->sk->sk_write_space = lowcomms_write_space;
|
|
|
|
con->sock->sk->sk_state_change = lowcomms_state_change;
|
2007-04-17 08:39:57 -06:00
|
|
|
con->sock->sk->sk_user_data = con;
|
2008-11-12 15:49:48 -07:00
|
|
|
con->sock->sk->sk_allocation = GFP_NOFS;
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
/* Add the port number to an IPv6 or 4 sockaddr and return the address
|
2006-11-02 09:19:21 -07:00
|
|
|
length */
|
|
|
|
static void make_sockaddr(struct sockaddr_storage *saddr, uint16_t port,
|
|
|
|
int *addr_len)
|
|
|
|
{
|
2007-04-17 08:39:57 -06:00
|
|
|
saddr->ss_family = dlm_local_addr[0]->ss_family;
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
if (saddr->ss_family == AF_INET) {
|
2006-11-02 09:19:21 -07:00
|
|
|
struct sockaddr_in *in4_addr = (struct sockaddr_in *)saddr;
|
|
|
|
in4_addr->sin_port = cpu_to_be16(port);
|
|
|
|
*addr_len = sizeof(struct sockaddr_in);
|
2007-04-17 08:39:57 -06:00
|
|
|
memset(&in4_addr->sin_zero, 0, sizeof(in4_addr->sin_zero));
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
} else {
|
2006-11-02 09:19:21 -07:00
|
|
|
struct sockaddr_in6 *in6_addr = (struct sockaddr_in6 *)saddr;
|
|
|
|
in6_addr->sin6_port = cpu_to_be16(port);
|
|
|
|
*addr_len = sizeof(struct sockaddr_in6);
|
|
|
|
}
|
2007-07-17 09:53:15 -06:00
|
|
|
memset((char *)saddr + *addr_len, 0, sizeof(struct sockaddr_storage) - *addr_len);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Close a remote connection and tidy up */
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
static void close_connection(struct connection *con, bool and_other)
|
2006-11-02 09:19:21 -07:00
|
|
|
{
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_lock(&con->sock_mutex);
|
2006-11-02 09:19:21 -07:00
|
|
|
|
|
|
|
if (con->sock) {
|
|
|
|
sock_release(con->sock);
|
|
|
|
con->sock = NULL;
|
|
|
|
}
|
|
|
|
if (con->othercon && and_other) {
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
/* Will only re-enter once. */
|
|
|
|
close_connection(con->othercon, false);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
if (con->rx_page) {
|
|
|
|
__free_page(con->rx_page);
|
|
|
|
con->rx_page = NULL;
|
|
|
|
}
|
2007-08-02 07:58:14 -06:00
|
|
|
|
2007-08-20 08:13:38 -06:00
|
|
|
con->retries = 0;
|
|
|
|
mutex_unlock(&con->sock_mutex);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
/* We only send shutdown messages to nodes that are not part of the cluster */
|
|
|
|
static void sctp_send_shutdown(sctp_assoc_t associd)
|
|
|
|
{
|
|
|
|
static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
|
|
|
|
struct msghdr outmessage;
|
|
|
|
struct cmsghdr *cmsg;
|
|
|
|
struct sctp_sndrcvinfo *sinfo;
|
|
|
|
int ret;
|
|
|
|
struct connection *con;
|
|
|
|
|
|
|
|
con = nodeid2con(0,0);
|
|
|
|
BUG_ON(con == NULL);
|
|
|
|
|
|
|
|
outmessage.msg_name = NULL;
|
|
|
|
outmessage.msg_namelen = 0;
|
|
|
|
outmessage.msg_control = outcmsg;
|
|
|
|
outmessage.msg_controllen = sizeof(outcmsg);
|
|
|
|
outmessage.msg_flags = MSG_EOR;
|
|
|
|
|
|
|
|
cmsg = CMSG_FIRSTHDR(&outmessage);
|
|
|
|
cmsg->cmsg_level = IPPROTO_SCTP;
|
|
|
|
cmsg->cmsg_type = SCTP_SNDRCV;
|
|
|
|
cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
|
|
|
|
outmessage.msg_controllen = cmsg->cmsg_len;
|
|
|
|
sinfo = CMSG_DATA(cmsg);
|
|
|
|
memset(sinfo, 0x00, sizeof(struct sctp_sndrcvinfo));
|
|
|
|
|
|
|
|
sinfo->sinfo_flags |= MSG_EOF;
|
|
|
|
sinfo->sinfo_assoc_id = associd;
|
|
|
|
|
|
|
|
ret = kernel_sendmsg(con->sock, &outmessage, NULL, 0, 0);
|
|
|
|
|
|
|
|
if (ret != 0)
|
|
|
|
log_print("send EOF to node failed: %d", ret);
|
|
|
|
}
|
|
|
|
|
2009-01-28 11:57:40 -07:00
|
|
|
static void sctp_init_failed_foreach(struct connection *con)
|
|
|
|
{
|
|
|
|
con->sctp_assoc = 0;
|
|
|
|
if (test_and_clear_bit(CF_CONNECT_PENDING, &con->flags)) {
|
|
|
|
if (!test_and_set_bit(CF_WRITE_PENDING, &con->flags))
|
|
|
|
queue_work(send_workqueue, &con->swork);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
/* INIT failed but we don't know which node...
|
|
|
|
restart INIT on all pending nodes */
|
|
|
|
static void sctp_init_failed(void)
|
|
|
|
{
|
2008-05-12 09:04:51 -06:00
|
|
|
mutex_lock(&connections_lock);
|
2009-01-28 11:57:40 -07:00
|
|
|
|
|
|
|
foreach_conn(sctp_init_failed_foreach);
|
|
|
|
|
2008-05-12 09:04:51 -06:00
|
|
|
mutex_unlock(&connections_lock);
|
2007-04-17 08:39:57 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Something happened to an association */
|
2007-04-26 12:46:49 -06:00
|
|
|
static void process_sctp_notification(struct connection *con,
|
|
|
|
struct msghdr *msg, char *buf)
|
2007-04-17 08:39:57 -06:00
|
|
|
{
|
|
|
|
union sctp_notification *sn = (union sctp_notification *)buf;
|
|
|
|
|
|
|
|
if (sn->sn_header.sn_type == SCTP_ASSOC_CHANGE) {
|
|
|
|
switch (sn->sn_assoc_change.sac_state) {
|
|
|
|
|
|
|
|
case SCTP_COMM_UP:
|
|
|
|
case SCTP_RESTART:
|
|
|
|
{
|
|
|
|
/* Check that the new node is in the lockspace */
|
|
|
|
struct sctp_prim prim;
|
|
|
|
int nodeid;
|
|
|
|
int prim_len, ret;
|
|
|
|
int addr_len;
|
|
|
|
struct connection *new_con;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We get this before any data for an association.
|
|
|
|
* We verify that the node is in the cluster and
|
|
|
|
* then peel off a socket for it.
|
|
|
|
*/
|
|
|
|
if ((int)sn->sn_assoc_change.sac_assoc_id <= 0) {
|
|
|
|
log_print("COMM_UP for invalid assoc ID %d",
|
2007-04-26 12:46:49 -06:00
|
|
|
(int)sn->sn_assoc_change.sac_assoc_id);
|
2007-04-17 08:39:57 -06:00
|
|
|
sctp_init_failed();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
memset(&prim, 0, sizeof(struct sctp_prim));
|
|
|
|
prim_len = sizeof(struct sctp_prim);
|
|
|
|
prim.ssp_assoc_id = sn->sn_assoc_change.sac_assoc_id;
|
|
|
|
|
|
|
|
ret = kernel_getsockopt(con->sock,
|
|
|
|
IPPROTO_SCTP,
|
|
|
|
SCTP_PRIMARY_ADDR,
|
|
|
|
(char*)&prim,
|
|
|
|
&prim_len);
|
|
|
|
if (ret < 0) {
|
|
|
|
log_print("getsockopt/sctp_primary_addr on "
|
|
|
|
"new assoc %d failed : %d",
|
|
|
|
(int)sn->sn_assoc_change.sac_assoc_id,
|
|
|
|
ret);
|
|
|
|
|
|
|
|
/* Retry INIT later */
|
|
|
|
new_con = assoc2con(sn->sn_assoc_change.sac_assoc_id);
|
|
|
|
if (new_con)
|
|
|
|
clear_bit(CF_CONNECT_PENDING, &con->flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
make_sockaddr(&prim.ssp_addr, 0, &addr_len);
|
2012-07-26 11:44:30 -06:00
|
|
|
if (addr_to_nodeid(&prim.ssp_addr, &nodeid)) {
|
2007-04-17 08:39:57 -06:00
|
|
|
unsigned char *b=(unsigned char *)&prim.ssp_addr;
|
|
|
|
log_print("reject connect from unknown addr");
|
2011-07-03 21:25:51 -06:00
|
|
|
print_hex_dump_bytes("ss: ", DUMP_PREFIX_NONE,
|
|
|
|
b, sizeof(struct sockaddr_storage));
|
2007-04-17 08:39:57 -06:00
|
|
|
sctp_send_shutdown(prim.ssp_assoc_id);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-05-15 09:50:57 -06:00
|
|
|
new_con = nodeid2con(nodeid, GFP_NOFS);
|
2007-04-17 08:39:57 -06:00
|
|
|
if (!new_con)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Peel off a new sock */
|
2012-03-07 22:55:59 -07:00
|
|
|
sctp_lock_sock(con->sock->sk);
|
|
|
|
ret = sctp_do_peeloff(con->sock->sk,
|
|
|
|
sn->sn_assoc_change.sac_assoc_id,
|
|
|
|
&new_con->sock);
|
|
|
|
sctp_release_sock(con->sock->sk);
|
2009-09-24 14:58:23 -06:00
|
|
|
if (ret < 0) {
|
2007-04-26 12:46:49 -06:00
|
|
|
log_print("Can't peel off a socket for "
|
2009-09-24 14:58:23 -06:00
|
|
|
"connection %d to node %d: err=%d",
|
2012-03-07 22:55:59 -07:00
|
|
|
(int)sn->sn_assoc_change.sac_assoc_id,
|
|
|
|
nodeid, ret);
|
2009-09-24 14:58:23 -06:00
|
|
|
return;
|
2007-04-17 08:39:57 -06:00
|
|
|
}
|
|
|
|
add_sock(new_con->sock, new_con);
|
|
|
|
|
2009-09-24 14:58:23 -06:00
|
|
|
log_print("connecting to %d sctp association %d",
|
|
|
|
nodeid, (int)sn->sn_assoc_change.sac_assoc_id);
|
2007-04-17 08:39:57 -06:00
|
|
|
|
|
|
|
/* Send any pending writes */
|
|
|
|
clear_bit(CF_CONNECT_PENDING, &new_con->flags);
|
|
|
|
clear_bit(CF_INIT_PENDING, &con->flags);
|
|
|
|
if (!test_and_set_bit(CF_WRITE_PENDING, &new_con->flags)) {
|
|
|
|
queue_work(send_workqueue, &new_con->swork);
|
|
|
|
}
|
|
|
|
if (!test_and_set_bit(CF_READ_PENDING, &new_con->flags))
|
|
|
|
queue_work(recv_workqueue, &new_con->rwork);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SCTP_COMM_LOST:
|
|
|
|
case SCTP_SHUTDOWN_COMP:
|
|
|
|
{
|
|
|
|
con = assoc2con(sn->sn_assoc_change.sac_assoc_id);
|
|
|
|
if (con) {
|
|
|
|
con->sctp_assoc = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* We don't know which INIT failed, so clear the PENDING flags
|
|
|
|
* on them all. if assoc_id is zero then it will then try
|
|
|
|
* again */
|
|
|
|
|
|
|
|
case SCTP_CANT_STR_ASSOC:
|
|
|
|
{
|
|
|
|
log_print("Can't start SCTP association - retrying");
|
|
|
|
sctp_init_failed();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
log_print("unexpected SCTP assoc change id=%d state=%d",
|
|
|
|
(int)sn->sn_assoc_change.sac_assoc_id,
|
|
|
|
sn->sn_assoc_change.sac_state);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-02 09:19:21 -07:00
|
|
|
/* Data received from remote end */
|
|
|
|
static int receive_from_sock(struct connection *con)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
2007-02-09 09:38:45 -07:00
|
|
|
struct msghdr msg = {};
|
|
|
|
struct kvec iov[2];
|
2006-11-02 09:19:21 -07:00
|
|
|
unsigned len;
|
|
|
|
int r;
|
|
|
|
int call_again_soon = 0;
|
2007-02-09 09:38:45 -07:00
|
|
|
int nvec;
|
2007-04-17 08:39:57 -06:00
|
|
|
char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_lock(&con->sock_mutex);
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2007-02-01 09:46:33 -07:00
|
|
|
if (con->sock == NULL) {
|
|
|
|
ret = -EAGAIN;
|
|
|
|
goto out_close;
|
|
|
|
}
|
|
|
|
|
2006-11-02 09:19:21 -07:00
|
|
|
if (con->rx_page == NULL) {
|
|
|
|
/*
|
|
|
|
* This doesn't need to be atomic, but I think it should
|
|
|
|
* improve performance if it is.
|
|
|
|
*/
|
|
|
|
con->rx_page = alloc_page(GFP_ATOMIC);
|
|
|
|
if (con->rx_page == NULL)
|
|
|
|
goto out_resched;
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
cbuf_init(&con->cb, PAGE_CACHE_SIZE);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
/* Only SCTP needs these really */
|
|
|
|
memset(&incmsg, 0, sizeof(incmsg));
|
|
|
|
msg.msg_control = incmsg;
|
|
|
|
msg.msg_controllen = sizeof(incmsg);
|
|
|
|
|
2006-11-02 09:19:21 -07:00
|
|
|
/*
|
|
|
|
* iov[0] is the bit of the circular buffer between the current end
|
|
|
|
* point (cb.base + cb.len) and the end of the buffer.
|
|
|
|
*/
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
iov[0].iov_len = con->cb.base - cbuf_data(&con->cb);
|
|
|
|
iov[0].iov_base = page_address(con->rx_page) + cbuf_data(&con->cb);
|
2007-03-13 11:08:45 -06:00
|
|
|
iov[1].iov_len = 0;
|
2007-02-09 09:38:45 -07:00
|
|
|
nvec = 1;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* iov[1] is the bit of the circular buffer between the start of the
|
|
|
|
* buffer and the start of the currently used section (cb.base)
|
|
|
|
*/
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
if (cbuf_data(&con->cb) >= con->cb.base) {
|
|
|
|
iov[0].iov_len = PAGE_CACHE_SIZE - cbuf_data(&con->cb);
|
2006-11-02 09:19:21 -07:00
|
|
|
iov[1].iov_len = con->cb.base;
|
|
|
|
iov[1].iov_base = page_address(con->rx_page);
|
2007-02-09 09:38:45 -07:00
|
|
|
nvec = 2;
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
len = iov[0].iov_len + iov[1].iov_len;
|
|
|
|
|
2007-02-09 09:38:45 -07:00
|
|
|
r = ret = kernel_recvmsg(con->sock, &msg, iov, nvec, len,
|
2006-11-02 09:19:21 -07:00
|
|
|
MSG_DONTWAIT | MSG_NOSIGNAL);
|
|
|
|
if (ret <= 0)
|
|
|
|
goto out_close;
|
2007-01-22 07:51:33 -07:00
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
/* Process SCTP notifications */
|
|
|
|
if (msg.msg_flags & MSG_NOTIFICATION) {
|
|
|
|
msg.msg_control = incmsg;
|
|
|
|
msg.msg_controllen = sizeof(incmsg);
|
|
|
|
|
|
|
|
process_sctp_notification(con, &msg,
|
2007-04-26 12:46:49 -06:00
|
|
|
page_address(con->rx_page) + con->cb.base);
|
2007-04-17 08:39:57 -06:00
|
|
|
mutex_unlock(&con->sock_mutex);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
BUG_ON(con->nodeid == 0);
|
|
|
|
|
2006-11-02 09:19:21 -07:00
|
|
|
if (ret == len)
|
|
|
|
call_again_soon = 1;
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
cbuf_add(&con->cb, ret);
|
2006-11-02 09:19:21 -07:00
|
|
|
ret = dlm_process_incoming_buffer(con->nodeid,
|
|
|
|
page_address(con->rx_page),
|
|
|
|
con->cb.base, con->cb.len,
|
|
|
|
PAGE_CACHE_SIZE);
|
|
|
|
if (ret == -EBADMSG) {
|
2007-04-26 12:46:49 -06:00
|
|
|
log_print("lowcomms: addr=%p, base=%u, len=%u, "
|
|
|
|
"iov_len=%u, iov_base[0]=%p, read=%d",
|
|
|
|
page_address(con->rx_page), con->cb.base, con->cb.len,
|
|
|
|
len, iov[0].iov_base, r);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
if (ret < 0)
|
|
|
|
goto out_close;
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
cbuf_eat(&con->cb, ret);
|
2006-11-02 09:19:21 -07:00
|
|
|
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
if (cbuf_empty(&con->cb) && !call_again_soon) {
|
2006-11-02 09:19:21 -07:00
|
|
|
__free_page(con->rx_page);
|
|
|
|
con->rx_page = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (call_again_soon)
|
|
|
|
goto out_resched;
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_unlock(&con->sock_mutex);
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
return 0;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
out_resched:
|
2007-01-15 07:33:34 -07:00
|
|
|
if (!test_and_set_bit(CF_READ_PENDING, &con->flags))
|
|
|
|
queue_work(recv_workqueue, &con->rwork);
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_unlock(&con->sock_mutex);
|
2007-01-22 07:51:33 -07:00
|
|
|
return -EAGAIN;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
out_close:
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_unlock(&con->sock_mutex);
|
2007-08-02 07:58:14 -06:00
|
|
|
if (ret != -EAGAIN) {
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
close_connection(con, false);
|
2006-11-02 09:19:21 -07:00
|
|
|
/* Reconnect when there is something to send */
|
|
|
|
}
|
2007-02-01 09:46:33 -07:00
|
|
|
/* Don't return success if we really got EOF */
|
|
|
|
if (ret == 0)
|
|
|
|
ret = -EAGAIN;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Listening socket is busy, accept a connection */
|
2007-04-17 08:39:57 -06:00
|
|
|
static int tcp_accept_from_sock(struct connection *con)
|
2006-11-02 09:19:21 -07:00
|
|
|
{
|
|
|
|
int result;
|
|
|
|
struct sockaddr_storage peeraddr;
|
|
|
|
struct socket *newsock;
|
|
|
|
int len;
|
|
|
|
int nodeid;
|
|
|
|
struct connection *newcon;
|
2007-01-22 07:51:33 -07:00
|
|
|
struct connection *addcon;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2012-03-30 10:46:08 -06:00
|
|
|
mutex_lock(&connections_lock);
|
|
|
|
if (!dlm_allow_conn) {
|
|
|
|
mutex_unlock(&connections_lock);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
mutex_unlock(&connections_lock);
|
|
|
|
|
2006-11-02 09:19:21 -07:00
|
|
|
memset(&peeraddr, 0, sizeof(peeraddr));
|
2007-04-17 08:39:57 -06:00
|
|
|
result = sock_create_kern(dlm_local_addr[0]->ss_family, SOCK_STREAM,
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
IPPROTO_TCP, &newsock);
|
2006-11-02 09:19:21 -07:00
|
|
|
if (result < 0)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_lock_nested(&con->sock_mutex, 0);
|
2006-11-02 09:19:21 -07:00
|
|
|
|
|
|
|
result = -ENOTCONN;
|
|
|
|
if (con->sock == NULL)
|
|
|
|
goto accept_err;
|
|
|
|
|
|
|
|
newsock->type = con->sock->type;
|
|
|
|
newsock->ops = con->sock->ops;
|
|
|
|
|
|
|
|
result = con->sock->ops->accept(con->sock, newsock, O_NONBLOCK);
|
|
|
|
if (result < 0)
|
|
|
|
goto accept_err;
|
|
|
|
|
|
|
|
/* Get the connected socket's peer */
|
|
|
|
memset(&peeraddr, 0, sizeof(peeraddr));
|
|
|
|
if (newsock->ops->getname(newsock, (struct sockaddr *)&peeraddr,
|
|
|
|
&len, 2)) {
|
|
|
|
result = -ECONNABORTED;
|
|
|
|
goto accept_err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get the new node's NODEID */
|
|
|
|
make_sockaddr(&peeraddr, 0, &len);
|
2012-07-26 11:44:30 -06:00
|
|
|
if (addr_to_nodeid(&peeraddr, &nodeid)) {
|
2011-07-03 21:25:51 -06:00
|
|
|
unsigned char *b=(unsigned char *)&peeraddr;
|
2007-04-26 12:46:49 -06:00
|
|
|
log_print("connect from non cluster node");
|
2011-07-03 21:25:51 -06:00
|
|
|
print_hex_dump_bytes("ss: ", DUMP_PREFIX_NONE,
|
|
|
|
b, sizeof(struct sockaddr_storage));
|
2006-11-02 09:19:21 -07:00
|
|
|
sock_release(newsock);
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_unlock(&con->sock_mutex);
|
2006-11-02 09:19:21 -07:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
log_print("got connection from %d", nodeid);
|
|
|
|
|
|
|
|
/* Check to see if we already have a connection to this node. This
|
|
|
|
* could happen if the two nodes initiate a connection at roughly
|
|
|
|
* the same time and the connections cross on the wire.
|
|
|
|
* In this case we store the incoming one in "othercon"
|
|
|
|
*/
|
2009-05-15 09:50:57 -06:00
|
|
|
newcon = nodeid2con(nodeid, GFP_NOFS);
|
2006-11-02 09:19:21 -07:00
|
|
|
if (!newcon) {
|
|
|
|
result = -ENOMEM;
|
|
|
|
goto accept_err;
|
|
|
|
}
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_lock_nested(&newcon->sock_mutex, 1);
|
2006-11-02 09:19:21 -07:00
|
|
|
if (newcon->sock) {
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
struct connection *othercon = newcon->othercon;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
|
|
|
if (!othercon) {
|
2009-05-15 09:50:57 -06:00
|
|
|
othercon = kmem_cache_zalloc(con_cache, GFP_NOFS);
|
2006-11-02 09:19:21 -07:00
|
|
|
if (!othercon) {
|
2007-04-26 12:46:49 -06:00
|
|
|
log_print("failed to allocate incoming socket");
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_unlock(&newcon->sock_mutex);
|
2006-11-02 09:19:21 -07:00
|
|
|
result = -ENOMEM;
|
|
|
|
goto accept_err;
|
|
|
|
}
|
|
|
|
othercon->nodeid = nodeid;
|
|
|
|
othercon->rx_action = receive_from_sock;
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_init(&othercon->sock_mutex);
|
2007-01-15 07:33:34 -07:00
|
|
|
INIT_WORK(&othercon->swork, process_send_sockets);
|
|
|
|
INIT_WORK(&othercon->rwork, process_recv_sockets);
|
2006-11-02 09:19:21 -07:00
|
|
|
set_bit(CF_IS_OTHERCON, &othercon->flags);
|
2007-08-20 08:13:38 -06:00
|
|
|
}
|
|
|
|
if (!othercon->sock) {
|
2006-11-02 09:19:21 -07:00
|
|
|
newcon->othercon = othercon;
|
2007-06-27 04:36:23 -06:00
|
|
|
othercon->sock = newsock;
|
|
|
|
newsock->sk->sk_user_data = othercon;
|
|
|
|
add_sock(newsock, othercon);
|
|
|
|
addcon = othercon;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
printk("Extra connection from node %d attempted\n", nodeid);
|
|
|
|
result = -EAGAIN;
|
2007-06-27 15:43:37 -06:00
|
|
|
mutex_unlock(&newcon->sock_mutex);
|
2007-06-27 04:36:23 -06:00
|
|
|
goto accept_err;
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
newsock->sk->sk_user_data = newcon;
|
|
|
|
newcon->rx_action = receive_from_sock;
|
|
|
|
add_sock(newsock, newcon);
|
2007-01-22 07:51:33 -07:00
|
|
|
addcon = newcon;
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_unlock(&newcon->sock_mutex);
|
2006-11-02 09:19:21 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Add it to the active queue in case we got data
|
2011-03-30 19:57:33 -06:00
|
|
|
* between processing the accept adding the socket
|
2006-11-02 09:19:21 -07:00
|
|
|
* to the read_sockets list
|
|
|
|
*/
|
2007-01-22 07:51:33 -07:00
|
|
|
if (!test_and_set_bit(CF_READ_PENDING, &addcon->flags))
|
|
|
|
queue_work(recv_workqueue, &addcon->rwork);
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_unlock(&con->sock_mutex);
|
2006-11-02 09:19:21 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
accept_err:
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_unlock(&con->sock_mutex);
|
2006-11-02 09:19:21 -07:00
|
|
|
sock_release(newsock);
|
|
|
|
|
|
|
|
if (result != -EAGAIN)
|
2007-04-26 12:46:49 -06:00
|
|
|
log_print("error accepting connection from node: %d", result);
|
2006-11-02 09:19:21 -07:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
static void free_entry(struct writequeue_entry *e)
|
|
|
|
{
|
|
|
|
__free_page(e->page);
|
|
|
|
kfree(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initiate an SCTP association.
|
|
|
|
This is a special case of send_to_sock() in that we don't yet have a
|
|
|
|
peeled-off socket for this association, so we use the listening socket
|
|
|
|
and add the primary IP address of the remote node.
|
|
|
|
*/
|
|
|
|
static void sctp_init_assoc(struct connection *con)
|
|
|
|
{
|
|
|
|
struct sockaddr_storage rem_addr;
|
|
|
|
char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
|
|
|
|
struct msghdr outmessage;
|
|
|
|
struct cmsghdr *cmsg;
|
|
|
|
struct sctp_sndrcvinfo *sinfo;
|
|
|
|
struct connection *base_con;
|
|
|
|
struct writequeue_entry *e;
|
|
|
|
int len, offset;
|
|
|
|
int ret;
|
|
|
|
int addrlen;
|
|
|
|
struct kvec iov[1];
|
|
|
|
|
|
|
|
if (test_and_set_bit(CF_INIT_PENDING, &con->flags))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (con->retries++ > MAX_CONNECT_RETRIES)
|
|
|
|
return;
|
|
|
|
|
2012-07-26 11:44:30 -06:00
|
|
|
if (nodeid_to_addr(con->nodeid, NULL, (struct sockaddr *)&rem_addr)) {
|
2007-04-17 08:39:57 -06:00
|
|
|
log_print("no address for nodeid %d", con->nodeid);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
base_con = nodeid2con(0, 0);
|
|
|
|
BUG_ON(base_con == NULL);
|
|
|
|
|
|
|
|
make_sockaddr(&rem_addr, dlm_config.ci_tcp_port, &addrlen);
|
|
|
|
|
|
|
|
outmessage.msg_name = &rem_addr;
|
|
|
|
outmessage.msg_namelen = addrlen;
|
|
|
|
outmessage.msg_control = outcmsg;
|
|
|
|
outmessage.msg_controllen = sizeof(outcmsg);
|
|
|
|
outmessage.msg_flags = MSG_EOR;
|
|
|
|
|
|
|
|
spin_lock(&con->writequeue_lock);
|
|
|
|
|
2009-09-18 13:31:47 -06:00
|
|
|
if (list_empty(&con->writequeue)) {
|
|
|
|
spin_unlock(&con->writequeue_lock);
|
|
|
|
log_print("writequeue empty for nodeid %d", con->nodeid);
|
|
|
|
return;
|
|
|
|
}
|
2007-04-17 08:39:57 -06:00
|
|
|
|
2009-09-18 13:31:47 -06:00
|
|
|
e = list_first_entry(&con->writequeue, struct writequeue_entry, list);
|
2007-04-17 08:39:57 -06:00
|
|
|
len = e->len;
|
|
|
|
offset = e->offset;
|
|
|
|
spin_unlock(&con->writequeue_lock);
|
|
|
|
|
|
|
|
/* Send the first block off the write queue */
|
|
|
|
iov[0].iov_base = page_address(e->page)+offset;
|
|
|
|
iov[0].iov_len = len;
|
|
|
|
|
|
|
|
cmsg = CMSG_FIRSTHDR(&outmessage);
|
|
|
|
cmsg->cmsg_level = IPPROTO_SCTP;
|
|
|
|
cmsg->cmsg_type = SCTP_SNDRCV;
|
|
|
|
cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
|
|
|
|
sinfo = CMSG_DATA(cmsg);
|
|
|
|
memset(sinfo, 0x00, sizeof(struct sctp_sndrcvinfo));
|
|
|
|
sinfo->sinfo_ppid = cpu_to_le32(dlm_our_nodeid());
|
|
|
|
outmessage.msg_controllen = cmsg->cmsg_len;
|
|
|
|
|
|
|
|
ret = kernel_sendmsg(base_con->sock, &outmessage, iov, 1, len);
|
|
|
|
if (ret < 0) {
|
2007-04-26 12:46:49 -06:00
|
|
|
log_print("Send first packet to node %d failed: %d",
|
|
|
|
con->nodeid, ret);
|
2007-04-17 08:39:57 -06:00
|
|
|
|
|
|
|
/* Try again later */
|
|
|
|
clear_bit(CF_CONNECT_PENDING, &con->flags);
|
|
|
|
clear_bit(CF_INIT_PENDING, &con->flags);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
spin_lock(&con->writequeue_lock);
|
|
|
|
e->offset += ret;
|
|
|
|
e->len -= ret;
|
|
|
|
|
|
|
|
if (e->len == 0 && e->users == 0) {
|
|
|
|
list_del(&e->list);
|
|
|
|
free_entry(e);
|
|
|
|
}
|
|
|
|
spin_unlock(&con->writequeue_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-02 09:19:21 -07:00
|
|
|
/* Connect a new socket to its peer */
|
2007-04-17 08:39:57 -06:00
|
|
|
static void tcp_connect_to_sock(struct connection *con)
|
2006-11-02 09:19:21 -07:00
|
|
|
{
|
2007-10-25 16:51:54 -06:00
|
|
|
struct sockaddr_storage saddr, src_addr;
|
2006-11-02 09:19:21 -07:00
|
|
|
int addr_len;
|
2009-07-14 11:17:51 -06:00
|
|
|
struct socket *sock = NULL;
|
2010-11-12 10:12:55 -07:00
|
|
|
int one = 1;
|
2012-07-26 11:44:30 -06:00
|
|
|
int result;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
|
|
|
if (con->nodeid == 0) {
|
|
|
|
log_print("attempt to connect sock 0 foiled");
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
return;
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_lock(&con->sock_mutex);
|
2006-11-02 09:19:21 -07:00
|
|
|
if (con->retries++ > MAX_CONNECT_RETRIES)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Some odd races can cause double-connects, ignore them */
|
2012-07-26 11:44:30 -06:00
|
|
|
if (con->sock)
|
2006-11-02 09:19:21 -07:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Create a socket to communicate with */
|
2007-04-17 08:39:57 -06:00
|
|
|
result = sock_create_kern(dlm_local_addr[0]->ss_family, SOCK_STREAM,
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
IPPROTO_TCP, &sock);
|
2006-11-02 09:19:21 -07:00
|
|
|
if (result < 0)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
memset(&saddr, 0, sizeof(saddr));
|
2012-07-26 11:44:30 -06:00
|
|
|
result = nodeid_to_addr(con->nodeid, &saddr, NULL);
|
|
|
|
if (result < 0) {
|
|
|
|
log_print("no address for nodeid %d", con->nodeid);
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
goto out_err;
|
2012-07-26 11:44:30 -06:00
|
|
|
}
|
2006-11-02 09:19:21 -07:00
|
|
|
|
|
|
|
sock->sk->sk_user_data = con;
|
|
|
|
con->rx_action = receive_from_sock;
|
2007-04-17 08:39:57 -06:00
|
|
|
con->connect_action = tcp_connect_to_sock;
|
|
|
|
add_sock(sock, con);
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2007-10-25 16:51:54 -06:00
|
|
|
/* Bind to our cluster-known address connecting to avoid
|
|
|
|
routing problems */
|
|
|
|
memcpy(&src_addr, dlm_local_addr[0], sizeof(src_addr));
|
|
|
|
make_sockaddr(&src_addr, 0, &addr_len);
|
|
|
|
result = sock->ops->bind(sock, (struct sockaddr *) &src_addr,
|
|
|
|
addr_len);
|
|
|
|
if (result < 0) {
|
|
|
|
log_print("could not bind for connect: %d", result);
|
|
|
|
/* This *may* not indicate a critical error */
|
|
|
|
}
|
|
|
|
|
2007-01-09 08:41:48 -07:00
|
|
|
make_sockaddr(&saddr, dlm_config.ci_tcp_port, &addr_len);
|
2006-11-02 09:19:21 -07:00
|
|
|
|
|
|
|
log_print("connecting to %d", con->nodeid);
|
2010-11-12 10:12:55 -07:00
|
|
|
|
|
|
|
/* Turn off Nagle's algorithm */
|
|
|
|
kernel_setsockopt(sock, SOL_TCP, TCP_NODELAY, (char *)&one,
|
|
|
|
sizeof(one));
|
|
|
|
|
2012-07-26 11:44:30 -06:00
|
|
|
result = sock->ops->connect(sock, (struct sockaddr *)&saddr, addr_len,
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
O_NONBLOCK);
|
2006-11-02 09:19:21 -07:00
|
|
|
if (result == -EINPROGRESS)
|
|
|
|
result = 0;
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
if (result == 0)
|
|
|
|
goto out;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
out_err:
|
2006-11-02 09:19:21 -07:00
|
|
|
if (con->sock) {
|
|
|
|
sock_release(con->sock);
|
|
|
|
con->sock = NULL;
|
2009-07-14 11:17:51 -06:00
|
|
|
} else if (sock) {
|
|
|
|
sock_release(sock);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Some errors are fatal and this list might need adjusting. For other
|
|
|
|
* errors we try again until the max number of retries is reached.
|
|
|
|
*/
|
2012-07-26 11:44:30 -06:00
|
|
|
if (result != -EHOSTUNREACH &&
|
|
|
|
result != -ENETUNREACH &&
|
|
|
|
result != -ENETDOWN &&
|
|
|
|
result != -EINVAL &&
|
|
|
|
result != -EPROTONOSUPPORT) {
|
|
|
|
log_print("connect %d try %d error %d", con->nodeid,
|
|
|
|
con->retries, result);
|
|
|
|
mutex_unlock(&con->sock_mutex);
|
|
|
|
msleep(1000);
|
2006-11-02 09:19:21 -07:00
|
|
|
lowcomms_connect_sock(con);
|
2012-07-26 11:44:30 -06:00
|
|
|
return;
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
out:
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_unlock(&con->sock_mutex);
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
return;
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
static struct socket *tcp_create_listen_sock(struct connection *con,
|
|
|
|
struct sockaddr_storage *saddr)
|
2006-11-02 09:19:21 -07:00
|
|
|
{
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
struct socket *sock = NULL;
|
2006-11-02 09:19:21 -07:00
|
|
|
int result = 0;
|
|
|
|
int one = 1;
|
|
|
|
int addr_len;
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
if (dlm_local_addr[0]->ss_family == AF_INET)
|
2006-11-02 09:19:21 -07:00
|
|
|
addr_len = sizeof(struct sockaddr_in);
|
|
|
|
else
|
|
|
|
addr_len = sizeof(struct sockaddr_in6);
|
|
|
|
|
|
|
|
/* Create a socket to communicate with */
|
2007-04-26 12:46:49 -06:00
|
|
|
result = sock_create_kern(dlm_local_addr[0]->ss_family, SOCK_STREAM,
|
|
|
|
IPPROTO_TCP, &sock);
|
2006-11-02 09:19:21 -07:00
|
|
|
if (result < 0) {
|
2007-04-26 12:46:49 -06:00
|
|
|
log_print("Can't create listening comms socket");
|
2006-11-02 09:19:21 -07:00
|
|
|
goto create_out;
|
|
|
|
}
|
|
|
|
|
2010-11-12 10:12:55 -07:00
|
|
|
/* Turn off Nagle's algorithm */
|
|
|
|
kernel_setsockopt(sock, SOL_TCP, TCP_NODELAY, (char *)&one,
|
|
|
|
sizeof(one));
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
result = kernel_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
|
|
|
|
(char *)&one, sizeof(one));
|
|
|
|
|
2006-11-02 09:19:21 -07:00
|
|
|
if (result < 0) {
|
2007-04-26 12:46:49 -06:00
|
|
|
log_print("Failed to set SO_REUSEADDR on socket: %d", result);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
2007-04-17 08:39:57 -06:00
|
|
|
con->rx_action = tcp_accept_from_sock;
|
|
|
|
con->connect_action = tcp_connect_to_sock;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
|
|
|
/* Bind to our port */
|
2007-01-09 08:41:48 -07:00
|
|
|
make_sockaddr(saddr, dlm_config.ci_tcp_port, &addr_len);
|
2006-11-02 09:19:21 -07:00
|
|
|
result = sock->ops->bind(sock, (struct sockaddr *) saddr, addr_len);
|
|
|
|
if (result < 0) {
|
2007-04-26 12:46:49 -06:00
|
|
|
log_print("Can't bind to port %d", dlm_config.ci_tcp_port);
|
2006-11-02 09:19:21 -07:00
|
|
|
sock_release(sock);
|
|
|
|
sock = NULL;
|
|
|
|
con->sock = NULL;
|
|
|
|
goto create_out;
|
|
|
|
}
|
2007-04-17 08:39:57 -06:00
|
|
|
result = kernel_setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE,
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
(char *)&one, sizeof(one));
|
2006-11-02 09:19:21 -07:00
|
|
|
if (result < 0) {
|
2007-04-26 12:46:49 -06:00
|
|
|
log_print("Set keepalive failed: %d", result);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
result = sock->ops->listen(sock, 5);
|
|
|
|
if (result < 0) {
|
2007-04-26 12:46:49 -06:00
|
|
|
log_print("Can't listen on port %d", dlm_config.ci_tcp_port);
|
2006-11-02 09:19:21 -07:00
|
|
|
sock_release(sock);
|
|
|
|
sock = NULL;
|
|
|
|
goto create_out;
|
|
|
|
}
|
|
|
|
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
create_out:
|
2006-11-02 09:19:21 -07:00
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
/* Get local addresses */
|
|
|
|
static void init_local(void)
|
|
|
|
{
|
|
|
|
struct sockaddr_storage sas, *addr;
|
|
|
|
int i;
|
|
|
|
|
2007-04-23 09:26:21 -06:00
|
|
|
dlm_local_count = 0;
|
2012-03-21 08:18:34 -06:00
|
|
|
for (i = 0; i < DLM_MAX_ADDR_COUNT; i++) {
|
2007-04-17 08:39:57 -06:00
|
|
|
if (dlm_our_addr(&sas, i))
|
|
|
|
break;
|
|
|
|
|
2009-11-30 15:34:43 -07:00
|
|
|
addr = kmalloc(sizeof(*addr), GFP_NOFS);
|
2007-04-17 08:39:57 -06:00
|
|
|
if (!addr)
|
|
|
|
break;
|
|
|
|
memcpy(addr, &sas, sizeof(*addr));
|
|
|
|
dlm_local_addr[dlm_local_count++] = addr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-04-26 12:46:49 -06:00
|
|
|
/* Bind to an IP address. SCTP allows multiple address so it can do
|
|
|
|
multi-homing */
|
|
|
|
static int add_sctp_bind_addr(struct connection *sctp_con,
|
|
|
|
struct sockaddr_storage *addr,
|
|
|
|
int addr_len, int num)
|
2007-04-17 08:39:57 -06:00
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
|
|
|
|
if (num == 1)
|
|
|
|
result = kernel_bind(sctp_con->sock,
|
|
|
|
(struct sockaddr *) addr,
|
|
|
|
addr_len);
|
|
|
|
else
|
|
|
|
result = kernel_setsockopt(sctp_con->sock, SOL_SCTP,
|
|
|
|
SCTP_SOCKOPT_BINDX_ADD,
|
|
|
|
(char *)addr, addr_len);
|
|
|
|
|
|
|
|
if (result < 0)
|
|
|
|
log_print("Can't bind to port %d addr number %d",
|
|
|
|
dlm_config.ci_tcp_port, num);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
/* Initialise SCTP socket and bind to all interfaces */
|
|
|
|
static int sctp_listen_for_all(void)
|
|
|
|
{
|
|
|
|
struct socket *sock = NULL;
|
|
|
|
struct sockaddr_storage localaddr;
|
|
|
|
struct sctp_event_subscribe subscribe;
|
|
|
|
int result = -EINVAL, num = 1, i, addr_len;
|
2009-11-30 15:34:43 -07:00
|
|
|
struct connection *con = nodeid2con(0, GFP_NOFS);
|
2007-04-17 08:39:57 -06:00
|
|
|
int bufsize = NEEDED_RMEM;
|
|
|
|
|
|
|
|
if (!con)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
log_print("Using SCTP for communications");
|
|
|
|
|
|
|
|
result = sock_create_kern(dlm_local_addr[0]->ss_family, SOCK_SEQPACKET,
|
|
|
|
IPPROTO_SCTP, &sock);
|
|
|
|
if (result < 0) {
|
|
|
|
log_print("Can't create comms socket, check SCTP is loaded");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Listen for events */
|
|
|
|
memset(&subscribe, 0, sizeof(subscribe));
|
|
|
|
subscribe.sctp_data_io_event = 1;
|
|
|
|
subscribe.sctp_association_event = 1;
|
|
|
|
subscribe.sctp_send_failure_event = 1;
|
|
|
|
subscribe.sctp_shutdown_event = 1;
|
|
|
|
subscribe.sctp_partial_delivery_event = 1;
|
|
|
|
|
2007-11-07 00:48:57 -07:00
|
|
|
result = kernel_setsockopt(sock, SOL_SOCKET, SO_RCVBUFFORCE,
|
2007-04-17 08:39:57 -06:00
|
|
|
(char *)&bufsize, sizeof(bufsize));
|
|
|
|
if (result)
|
2007-04-26 12:46:49 -06:00
|
|
|
log_print("Error increasing buffer space on socket %d", result);
|
2007-04-17 08:39:57 -06:00
|
|
|
|
|
|
|
result = kernel_setsockopt(sock, SOL_SCTP, SCTP_EVENTS,
|
2007-04-26 12:46:49 -06:00
|
|
|
(char *)&subscribe, sizeof(subscribe));
|
2007-04-17 08:39:57 -06:00
|
|
|
if (result < 0) {
|
|
|
|
log_print("Failed to set SCTP_EVENTS on socket: result=%d",
|
|
|
|
result);
|
|
|
|
goto create_delsock;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Init con struct */
|
|
|
|
sock->sk->sk_user_data = con;
|
|
|
|
con->sock = sock;
|
|
|
|
con->sock->sk->sk_data_ready = lowcomms_data_ready;
|
|
|
|
con->rx_action = receive_from_sock;
|
|
|
|
con->connect_action = sctp_init_assoc;
|
|
|
|
|
|
|
|
/* Bind to all interfaces. */
|
|
|
|
for (i = 0; i < dlm_local_count; i++) {
|
|
|
|
memcpy(&localaddr, dlm_local_addr[i], sizeof(localaddr));
|
|
|
|
make_sockaddr(&localaddr, dlm_config.ci_tcp_port, &addr_len);
|
|
|
|
|
|
|
|
result = add_sctp_bind_addr(con, &localaddr, addr_len, num);
|
|
|
|
if (result)
|
|
|
|
goto create_delsock;
|
|
|
|
++num;
|
|
|
|
}
|
|
|
|
|
|
|
|
result = sock->ops->listen(sock, 5);
|
|
|
|
if (result < 0) {
|
|
|
|
log_print("Can't set socket listening");
|
|
|
|
goto create_delsock;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
create_delsock:
|
|
|
|
sock_release(sock);
|
|
|
|
con->sock = NULL;
|
|
|
|
out:
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tcp_listen_for_all(void)
|
2006-11-02 09:19:21 -07:00
|
|
|
{
|
|
|
|
struct socket *sock = NULL;
|
2009-11-30 15:34:43 -07:00
|
|
|
struct connection *con = nodeid2con(0, GFP_NOFS);
|
2006-11-02 09:19:21 -07:00
|
|
|
int result = -EINVAL;
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
if (!con)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2006-11-02 09:19:21 -07:00
|
|
|
/* We don't support multi-homed hosts */
|
2007-04-17 08:39:57 -06:00
|
|
|
if (dlm_local_addr[1] != NULL) {
|
2007-04-26 12:46:49 -06:00
|
|
|
log_print("TCP protocol can't handle multi-homed hosts, "
|
|
|
|
"try SCTP");
|
2007-04-17 08:39:57 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
log_print("Using TCP for communications");
|
|
|
|
|
|
|
|
sock = tcp_create_listen_sock(con, dlm_local_addr[0]);
|
2006-11-02 09:19:21 -07:00
|
|
|
if (sock) {
|
|
|
|
add_sock(sock, con);
|
|
|
|
result = 0;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
result = -EADDRINUSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static struct writequeue_entry *new_writequeue_entry(struct connection *con,
|
|
|
|
gfp_t allocation)
|
|
|
|
{
|
|
|
|
struct writequeue_entry *entry;
|
|
|
|
|
|
|
|
entry = kmalloc(sizeof(struct writequeue_entry), allocation);
|
|
|
|
if (!entry)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
entry->page = alloc_page(allocation);
|
|
|
|
if (!entry->page) {
|
|
|
|
kfree(entry);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
entry->offset = 0;
|
|
|
|
entry->len = 0;
|
|
|
|
entry->end = 0;
|
|
|
|
entry->users = 0;
|
|
|
|
entry->con = con;
|
|
|
|
|
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
|
2007-04-26 12:46:49 -06:00
|
|
|
void *dlm_lowcomms_get_buffer(int nodeid, int len, gfp_t allocation, char **ppc)
|
2006-11-02 09:19:21 -07:00
|
|
|
{
|
|
|
|
struct connection *con;
|
|
|
|
struct writequeue_entry *e;
|
|
|
|
int offset = 0;
|
|
|
|
int users = 0;
|
|
|
|
|
|
|
|
con = nodeid2con(nodeid, allocation);
|
|
|
|
if (!con)
|
|
|
|
return NULL;
|
|
|
|
|
2007-01-02 10:08:54 -07:00
|
|
|
spin_lock(&con->writequeue_lock);
|
2006-11-02 09:19:21 -07:00
|
|
|
e = list_entry(con->writequeue.prev, struct writequeue_entry, list);
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
if ((&e->list == &con->writequeue) ||
|
2006-11-02 09:19:21 -07:00
|
|
|
(PAGE_CACHE_SIZE - e->end < len)) {
|
|
|
|
e = NULL;
|
|
|
|
} else {
|
|
|
|
offset = e->end;
|
|
|
|
e->end += len;
|
|
|
|
users = e->users++;
|
|
|
|
}
|
|
|
|
spin_unlock(&con->writequeue_lock);
|
|
|
|
|
|
|
|
if (e) {
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
got_one:
|
2006-11-02 09:19:21 -07:00
|
|
|
*ppc = page_address(e->page) + offset;
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
|
|
|
e = new_writequeue_entry(con, allocation);
|
|
|
|
if (e) {
|
|
|
|
spin_lock(&con->writequeue_lock);
|
|
|
|
offset = e->end;
|
|
|
|
e->end += len;
|
|
|
|
users = e->users++;
|
|
|
|
list_add_tail(&e->list, &con->writequeue);
|
|
|
|
spin_unlock(&con->writequeue_lock);
|
|
|
|
goto got_one;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void dlm_lowcomms_commit_buffer(void *mh)
|
|
|
|
{
|
|
|
|
struct writequeue_entry *e = (struct writequeue_entry *)mh;
|
|
|
|
struct connection *con = e->con;
|
|
|
|
int users;
|
|
|
|
|
2007-01-02 10:08:54 -07:00
|
|
|
spin_lock(&con->writequeue_lock);
|
2006-11-02 09:19:21 -07:00
|
|
|
users = --e->users;
|
|
|
|
if (users)
|
|
|
|
goto out;
|
|
|
|
e->len = e->end - e->offset;
|
|
|
|
spin_unlock(&con->writequeue_lock);
|
|
|
|
|
2007-01-15 07:33:34 -07:00
|
|
|
if (!test_and_set_bit(CF_WRITE_PENDING, &con->flags)) {
|
|
|
|
queue_work(send_workqueue, &con->swork);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
out:
|
2006-11-02 09:19:21 -07:00
|
|
|
spin_unlock(&con->writequeue_lock);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Send a message */
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
static void send_to_sock(struct connection *con)
|
2006-11-02 09:19:21 -07:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
const int msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL;
|
|
|
|
struct writequeue_entry *e;
|
|
|
|
int len, offset;
|
2010-11-12 10:15:20 -07:00
|
|
|
int count = 0;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_lock(&con->sock_mutex);
|
2006-11-02 09:19:21 -07:00
|
|
|
if (con->sock == NULL)
|
|
|
|
goto out_connect;
|
|
|
|
|
|
|
|
spin_lock(&con->writequeue_lock);
|
|
|
|
for (;;) {
|
|
|
|
e = list_entry(con->writequeue.next, struct writequeue_entry,
|
|
|
|
list);
|
|
|
|
if ((struct list_head *) e == &con->writequeue)
|
|
|
|
break;
|
|
|
|
|
|
|
|
len = e->len;
|
|
|
|
offset = e->offset;
|
|
|
|
BUG_ON(len == 0 && e->users == 0);
|
|
|
|
spin_unlock(&con->writequeue_lock);
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
if (len) {
|
2009-08-24 12:18:04 -06:00
|
|
|
ret = kernel_sendpage(con->sock, e->page, offset, len,
|
|
|
|
msg_flags);
|
2007-09-14 01:49:21 -06:00
|
|
|
if (ret == -EAGAIN || ret == 0) {
|
2010-11-10 22:56:39 -07:00
|
|
|
if (ret == -EAGAIN &&
|
|
|
|
test_bit(SOCK_ASYNC_NOSPACE, &con->sock->flags) &&
|
|
|
|
!test_and_set_bit(CF_APP_LIMITED, &con->flags)) {
|
|
|
|
/* Notify TCP that we're limited by the
|
|
|
|
* application window size.
|
|
|
|
*/
|
|
|
|
set_bit(SOCK_NOSPACE, &con->sock->flags);
|
|
|
|
con->sock->sk->sk_write_pending++;
|
|
|
|
}
|
2007-09-14 01:49:21 -06:00
|
|
|
cond_resched();
|
2006-11-02 09:19:21 -07:00
|
|
|
goto out;
|
2012-08-13 00:29:55 -06:00
|
|
|
} else if (ret < 0)
|
2006-11-02 09:19:21 -07:00
|
|
|
goto send_error;
|
2007-09-14 01:49:21 -06:00
|
|
|
}
|
2010-11-12 10:15:20 -07:00
|
|
|
|
|
|
|
/* Don't starve people filling buffers */
|
|
|
|
if (++count >= MAX_SEND_MSG_COUNT) {
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
cond_resched();
|
2010-11-12 10:15:20 -07:00
|
|
|
count = 0;
|
|
|
|
}
|
2006-11-02 09:19:21 -07:00
|
|
|
|
|
|
|
spin_lock(&con->writequeue_lock);
|
|
|
|
e->offset += ret;
|
|
|
|
e->len -= ret;
|
|
|
|
|
|
|
|
if (e->len == 0 && e->users == 0) {
|
|
|
|
list_del(&e->list);
|
|
|
|
free_entry(e);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(&con->writequeue_lock);
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
out:
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_unlock(&con->sock_mutex);
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
return;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
send_error:
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_unlock(&con->sock_mutex);
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
close_connection(con, false);
|
2006-11-02 09:19:21 -07:00
|
|
|
lowcomms_connect_sock(con);
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
return;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
out_connect:
|
2007-01-24 04:17:59 -07:00
|
|
|
mutex_unlock(&con->sock_mutex);
|
2007-04-17 08:39:57 -06:00
|
|
|
if (!test_bit(CF_INIT_PENDING, &con->flags))
|
|
|
|
lowcomms_connect_sock(con);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void clean_one_writequeue(struct connection *con)
|
|
|
|
{
|
2009-01-28 11:57:40 -07:00
|
|
|
struct writequeue_entry *e, *safe;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
|
|
|
spin_lock(&con->writequeue_lock);
|
2009-01-28 11:57:40 -07:00
|
|
|
list_for_each_entry_safe(e, safe, &con->writequeue, list) {
|
2006-11-02 09:19:21 -07:00
|
|
|
list_del(&e->list);
|
|
|
|
free_entry(e);
|
|
|
|
}
|
|
|
|
spin_unlock(&con->writequeue_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Called from recovery when it knows that a node has
|
|
|
|
left the cluster */
|
|
|
|
int dlm_lowcomms_close(int nodeid)
|
|
|
|
{
|
|
|
|
struct connection *con;
|
2012-07-26 11:44:30 -06:00
|
|
|
struct dlm_node_addr *na;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
|
|
|
log_print("closing connection to node %d", nodeid);
|
|
|
|
con = nodeid2con(nodeid, 0);
|
|
|
|
if (con) {
|
2009-08-11 15:18:23 -06:00
|
|
|
clear_bit(CF_CONNECT_PENDING, &con->flags);
|
|
|
|
clear_bit(CF_WRITE_PENDING, &con->flags);
|
|
|
|
set_bit(CF_CLOSE, &con->flags);
|
|
|
|
if (cancel_work_sync(&con->swork))
|
|
|
|
log_print("canceled swork for node %d", nodeid);
|
|
|
|
if (cancel_work_sync(&con->rwork))
|
|
|
|
log_print("canceled rwork for node %d", nodeid);
|
2006-11-02 09:19:21 -07:00
|
|
|
clean_one_writequeue(con);
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
close_connection(con, true);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
2012-07-26 11:44:30 -06:00
|
|
|
|
|
|
|
spin_lock(&dlm_node_addrs_spin);
|
|
|
|
na = find_node_addr(nodeid);
|
|
|
|
if (na) {
|
|
|
|
list_del(&na->list);
|
|
|
|
while (na->addr_count--)
|
|
|
|
kfree(na->addr[na->addr_count]);
|
|
|
|
kfree(na);
|
|
|
|
}
|
|
|
|
spin_unlock(&dlm_node_addrs_spin);
|
|
|
|
|
2006-11-02 09:19:21 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
/* Receive workqueue function */
|
2007-01-15 07:33:34 -07:00
|
|
|
static void process_recv_sockets(struct work_struct *work)
|
2006-11-02 09:19:21 -07:00
|
|
|
{
|
2007-01-15 07:33:34 -07:00
|
|
|
struct connection *con = container_of(work, struct connection, rwork);
|
|
|
|
int err;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2007-01-15 07:33:34 -07:00
|
|
|
clear_bit(CF_READ_PENDING, &con->flags);
|
|
|
|
do {
|
|
|
|
err = con->rx_action(con);
|
|
|
|
} while (!err);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
/* Send workqueue function */
|
2007-01-15 07:33:34 -07:00
|
|
|
static void process_send_sockets(struct work_struct *work)
|
2006-11-02 09:19:21 -07:00
|
|
|
{
|
2007-01-15 07:33:34 -07:00
|
|
|
struct connection *con = container_of(work, struct connection, swork);
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2007-01-15 07:33:34 -07:00
|
|
|
if (test_and_clear_bit(CF_CONNECT_PENDING, &con->flags)) {
|
2007-04-17 08:39:57 -06:00
|
|
|
con->connect_action(con);
|
2009-08-11 15:18:23 -06:00
|
|
|
set_bit(CF_WRITE_PENDING, &con->flags);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
2009-08-11 15:18:23 -06:00
|
|
|
if (test_and_clear_bit(CF_WRITE_PENDING, &con->flags))
|
|
|
|
send_to_sock(con);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Discard all entries on the write queues */
|
|
|
|
static void clean_writequeues(void)
|
|
|
|
{
|
2009-01-28 11:57:40 -07:00
|
|
|
foreach_conn(clean_one_writequeue);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
2007-01-15 07:33:34 -07:00
|
|
|
static void work_stop(void)
|
2006-11-02 09:19:21 -07:00
|
|
|
{
|
2007-01-15 07:33:34 -07:00
|
|
|
destroy_workqueue(recv_workqueue);
|
|
|
|
destroy_workqueue(send_workqueue);
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
2007-01-15 07:33:34 -07:00
|
|
|
static int work_start(void)
|
2006-11-02 09:19:21 -07:00
|
|
|
{
|
2011-03-10 12:22:34 -07:00
|
|
|
recv_workqueue = alloc_workqueue("dlm_recv",
|
|
|
|
WQ_UNBOUND | WQ_MEM_RECLAIM, 1);
|
2010-12-13 12:42:24 -07:00
|
|
|
if (!recv_workqueue) {
|
|
|
|
log_print("can't start dlm_recv");
|
|
|
|
return -ENOMEM;
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
2011-03-10 12:22:34 -07:00
|
|
|
send_workqueue = alloc_workqueue("dlm_send",
|
|
|
|
WQ_UNBOUND | WQ_MEM_RECLAIM, 1);
|
2010-12-13 12:42:24 -07:00
|
|
|
if (!send_workqueue) {
|
|
|
|
log_print("can't start dlm_send");
|
2007-01-15 07:33:34 -07:00
|
|
|
destroy_workqueue(recv_workqueue);
|
2010-12-13 12:42:24 -07:00
|
|
|
return -ENOMEM;
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-28 11:57:40 -07:00
|
|
|
static void stop_conn(struct connection *con)
|
2006-11-02 09:19:21 -07:00
|
|
|
{
|
2009-01-28 11:57:40 -07:00
|
|
|
con->flags |= 0x0F;
|
2009-05-07 09:54:16 -06:00
|
|
|
if (con->sock && con->sock->sk)
|
2009-01-28 11:57:40 -07:00
|
|
|
con->sock->sk->sk_user_data = NULL;
|
|
|
|
}
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2009-01-28 11:57:40 -07:00
|
|
|
static void free_conn(struct connection *con)
|
|
|
|
{
|
|
|
|
close_connection(con, true);
|
|
|
|
if (con->othercon)
|
|
|
|
kmem_cache_free(con_cache, con->othercon);
|
|
|
|
hlist_del(&con->list);
|
|
|
|
kmem_cache_free(con_cache, con);
|
|
|
|
}
|
|
|
|
|
|
|
|
void dlm_lowcomms_stop(void)
|
|
|
|
{
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
/* Set all the flags to prevent any
|
2006-11-02 09:19:21 -07:00
|
|
|
socket activity.
|
|
|
|
*/
|
2008-05-12 09:04:51 -06:00
|
|
|
mutex_lock(&connections_lock);
|
2012-03-30 10:46:08 -06:00
|
|
|
dlm_allow_conn = 0;
|
2009-01-28 11:57:40 -07:00
|
|
|
foreach_conn(stop_conn);
|
2008-05-12 09:04:51 -06:00
|
|
|
mutex_unlock(&connections_lock);
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
|
2007-01-15 07:33:34 -07:00
|
|
|
work_stop();
|
2007-04-17 08:39:57 -06:00
|
|
|
|
2008-05-12 09:04:51 -06:00
|
|
|
mutex_lock(&connections_lock);
|
2006-11-02 09:19:21 -07:00
|
|
|
clean_writequeues();
|
|
|
|
|
2009-01-28 11:57:40 -07:00
|
|
|
foreach_conn(free_conn);
|
|
|
|
|
2008-05-12 09:04:51 -06:00
|
|
|
mutex_unlock(&connections_lock);
|
2006-11-02 09:19:21 -07:00
|
|
|
kmem_cache_destroy(con_cache);
|
|
|
|
}
|
|
|
|
|
|
|
|
int dlm_lowcomms_start(void)
|
|
|
|
{
|
2007-04-17 08:39:57 -06:00
|
|
|
int error = -EINVAL;
|
|
|
|
struct connection *con;
|
2009-01-28 11:57:40 -07:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < CONN_HASH_SIZE; i++)
|
|
|
|
INIT_HLIST_HEAD(&connection_hash[i]);
|
2006-11-02 09:19:21 -07:00
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
init_local();
|
|
|
|
if (!dlm_local_count) {
|
2007-04-26 12:46:49 -06:00
|
|
|
error = -ENOTCONN;
|
2006-11-02 09:19:21 -07:00
|
|
|
log_print("no local IP address has been set");
|
2012-03-30 10:46:08 -06:00
|
|
|
goto fail;
|
2006-11-02 09:19:21 -07:00
|
|
|
}
|
|
|
|
|
2007-04-17 08:39:57 -06:00
|
|
|
error = -ENOMEM;
|
2006-11-02 09:19:21 -07:00
|
|
|
con_cache = kmem_cache_create("dlm_conn", sizeof(struct connection),
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
__alignof__(struct connection), 0,
|
2007-07-19 19:11:58 -06:00
|
|
|
NULL);
|
2006-11-02 09:19:21 -07:00
|
|
|
if (!con_cache)
|
2012-03-30 10:46:08 -06:00
|
|
|
goto fail;
|
|
|
|
|
|
|
|
error = work_start();
|
|
|
|
if (error)
|
|
|
|
goto fail_destroy;
|
|
|
|
|
|
|
|
dlm_allow_conn = 1;
|
2006-11-02 09:19:21 -07:00
|
|
|
|
|
|
|
/* Start listening */
|
2007-04-17 08:39:57 -06:00
|
|
|
if (dlm_config.ci_protocol == 0)
|
|
|
|
error = tcp_listen_for_all();
|
|
|
|
else
|
|
|
|
error = sctp_listen_for_all();
|
2006-11-02 09:19:21 -07:00
|
|
|
if (error)
|
|
|
|
goto fail_unlisten;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
[DLM] Clean up lowcomms
This fixes up most of the things pointed out by akpm and Pavel Machek
with comments below indicating why some things have been left:
Andrew Morton wrote:
>
>> +static struct nodeinfo *nodeid2nodeinfo(int nodeid, gfp_t alloc)
>> +{
>> + struct nodeinfo *ni;
>> + int r;
>> + int n;
>> +
>> + down_read(&nodeinfo_lock);
>
> Given that this function can sleep, I wonder if `alloc' is useful.
>
> I see lots of callers passing in a literal "0" for `alloc'. That's in fact
> a secret (GFP_ATOMIC & ~__GFP_HIGH). I doubt if that's what you really
> meant. Particularly as the code could at least have used __GFP_WAIT (aka
> GFP_NOIO) which is much, much more reliable than "0". In fact "0" is the
> least reliable mode possible.
>
> IOW, this is all bollixed up.
When 0 is passed into nodeid2nodeinfo the function does not try to allocate a
new structure at all. it's an indication that the caller only wants the nodeinfo
struct for that nodeid if there actually is one in existance.
I've tidied the function itself so it's more obvious, (and tidier!)
>> +/* Data received from remote end */
>> +static int receive_from_sock(void)
>> +{
>> + int ret = 0;
>> + struct msghdr msg;
>> + struct kvec iov[2];
>> + unsigned len;
>> + int r;
>> + struct sctp_sndrcvinfo *sinfo;
>> + struct cmsghdr *cmsg;
>> + struct nodeinfo *ni;
>> +
>> + /* These two are marginally too big for stack allocation, but this
>> + * function is (currently) only called by dlm_recvd so static should be
>> + * OK.
>> + */
>> + static struct sockaddr_storage msgname;
>> + static char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> whoa. This is globally singly-threaded code??
Yes. it is only ever run in the context of dlm_recvd.
>>
>> +static void initiate_association(int nodeid)
>> +{
>> + struct sockaddr_storage rem_addr;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Another static buffer to worry about. Globally singly-threaded code?
Yes. Only ever called by dlm_sendd.
>> +
>> +/* Send a message */
>> +static int send_to_sock(struct nodeinfo *ni)
>> +{
>> + int ret = 0;
>> + struct writequeue_entry *e;
>> + int len, offset;
>> + struct msghdr outmsg;
>> + static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
>
> Singly-threaded?
Yep.
>>
>> +static void dealloc_nodeinfo(void)
>> +{
>> + int i;
>> +
>> + for (i=1; i<=max_nodeid; i++) {
>> + struct nodeinfo *ni = nodeid2nodeinfo(i, 0);
>> + if (ni) {
>> + idr_remove(&nodeinfo_idr, i);
>
> Didn't that need locking?
Not. it's only ever called at DLM shutdown after all the other threads
have been stopped.
>>
>> +static int write_list_empty(void)
>> +{
>> + int status;
>> +
>> + spin_lock_bh(&write_nodes_lock);
>> + status = list_empty(&write_nodes);
>> + spin_unlock_bh(&write_nodes_lock);
>> +
>> + return status;
>> +}
>
> This function's return value is meaningless. As soon as the lock gets
> dropped, the return value can get out of sync with reality.
>
> Looking at the caller, this _might_ happen to be OK, but it's a nasty and
> dangerous thing. Really the locking should be moved into the caller.
It's just an optimisation to allow the caller to schedule if there is no work
to do. if something arrives immediately afterwards then it will get picked up
when the process re-awakes (and it will be woken by that arrival).
The 'accepting' atomic has gone completely. as Andrew pointed out it didn't
really achieve much anyway. I suspect it was a plaster over some other
startup or shutdown bug to be honest.
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Andrew Morton <akpm@osdl.org>
Cc: Pavel Machek <pavel@ucw.cz>
2006-12-06 08:10:37 -07:00
|
|
|
fail_unlisten:
|
2012-03-30 10:46:08 -06:00
|
|
|
dlm_allow_conn = 0;
|
2007-04-17 08:39:57 -06:00
|
|
|
con = nodeid2con(0,0);
|
|
|
|
if (con) {
|
|
|
|
close_connection(con, false);
|
|
|
|
kmem_cache_free(con_cache, con);
|
|
|
|
}
|
2012-03-30 10:46:08 -06:00
|
|
|
fail_destroy:
|
2006-11-02 09:19:21 -07:00
|
|
|
kmem_cache_destroy(con_cache);
|
2012-03-30 10:46:08 -06:00
|
|
|
fail:
|
2006-11-02 09:19:21 -07:00
|
|
|
return error;
|
|
|
|
}
|
2012-07-26 11:44:30 -06:00
|
|
|
|
|
|
|
void dlm_lowcomms_exit(void)
|
|
|
|
{
|
|
|
|
struct dlm_node_addr *na, *safe;
|
|
|
|
|
|
|
|
spin_lock(&dlm_node_addrs_spin);
|
|
|
|
list_for_each_entry_safe(na, safe, &dlm_node_addrs, list) {
|
|
|
|
list_del(&na->list);
|
|
|
|
while (na->addr_count--)
|
|
|
|
kfree(na->addr[na->addr_count]);
|
|
|
|
kfree(na);
|
|
|
|
}
|
|
|
|
spin_unlock(&dlm_node_addrs_spin);
|
|
|
|
}
|