[DRBD-cvs] drbd by phil; * [Was sugested by LGE] removed drbd_que...
drbd-user@lists.linbit.com
drbd-user@lists.linbit.com
Sat, 6 Mar 2004 14:28:18 +0100 (CET)
DRBD CVS committal
Author : phil
Module : drbd
Dir : drbd/drbd
Modified Files:
Tag: rel-0_7-branch
drbd_actlog.c drbd_int.h drbd_main.c drbd_receiver.c
Log Message:
* [Was sugested by LGE] removed drbd_queue_signal() and use force_sig
instead. -- Now we can not get confused by userland's signals.
Tested. Seems to work.
* [Was sugested by LGE] Issue Write Hints right after data blocks.
Is necessary for propper L26 support. Tested. Seems to work.
* Backed out one chunk of latest LGE's patches. Thinko in drbdd_init()
===================================================================
RCS file: /var/lib/cvs/drbd/drbd/drbd/Attic/drbd_actlog.c,v
retrieving revision 1.1.2.73
retrieving revision 1.1.2.74
diff -u -3 -r1.1.2.73 -r1.1.2.74
--- drbd_actlog.c 4 Mar 2004 16:05:29 -0000 1.1.2.73
+++ drbd_actlog.c 6 Mar 2004 13:28:13 -0000 1.1.2.74
@@ -133,8 +133,8 @@
if (!al_ext) {
if (al_flags & LC_STARVING)
WARN("Have to wait for LRU element (AL too small?)\n");
- if (al_flags & LC_DIRTY)
- WARN("Ongoing AL update (AL device too slow?)\n");
+ //if (al_flags & LC_DIRTY) // too noisy
+ //WARN("Ongoing AL update (AL device too slow?)\n");
}
return al_ext;
===================================================================
RCS file: /var/lib/cvs/drbd/drbd/drbd/drbd_int.h,v
retrieving revision 1.58.2.131
retrieving revision 1.58.2.132
diff -u -3 -r1.58.2.131 -r1.58.2.132
--- drbd_int.h 6 Mar 2004 08:45:28 -0000 1.58.2.131
+++ drbd_int.h 6 Mar 2004 13:28:13 -0000 1.58.2.132
@@ -554,6 +554,7 @@
// bitfield? enum?
/* flag bits */
#define ISSUE_BARRIER 0
+#define ISSUE_IO_HINT 1
#define SEND_PING 2
#define WRITER_PRESENT 3
#define STOP_SYNC_TIMER 4
@@ -810,7 +811,6 @@
extern int bm_count_sectors(struct BitMap* sbm, unsigned long enr);
extern int bm_end_of_dev_case(struct BitMap* sbm);
-extern void drbd_queue_signal(int signal,struct task_struct *task);
extern drbd_dev *drbd_conf;
extern int minor_count;
@@ -1012,7 +1012,7 @@
}
static inline void wake_asender(drbd_dev *mdev) {
- drbd_queue_signal(DRBD_SIG, mdev->asender.task);
+ force_sig(DRBD_SIG, mdev->asender.task);
}
static inline void request_ping(drbd_dev *mdev) {
===================================================================
RCS file: /var/lib/cvs/drbd/drbd/drbd/drbd_main.c,v
retrieving revision 1.73.2.137
retrieving revision 1.73.2.138
diff -u -3 -r1.73.2.137 -r1.73.2.138
--- drbd_main.c 6 Mar 2004 08:45:28 -0000 1.73.2.137
+++ drbd_main.c 6 Mar 2004 13:28:13 -0000 1.73.2.138
@@ -346,15 +346,9 @@
}
#endif
-void drbd_daemonize(void) {
+STATIC void drbd_daemonize(void) {
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
- sigset_t enable;
-
daemonize("drbd_thread");
- // Linux 2.6.x's daemonize blocks all signals. Unblock "our" signals.
-
- siginitset(&enable, DRBD_SHUTDOWNSIGMASK );
- sigprocmask(SIG_UNBLOCK, &enable, NULL);
#else
daemonize();
#endif
@@ -474,7 +468,7 @@
smp_mb(); /* should not be necessary, since the next
instruction is spinlock, but anyways */
- drbd_queue_signal(DRBD_SIGKILL,thi->task);
+ force_sig(DRBD_SIGKILL,thi->task);
if(wait) {
down(&thi->mutex); // wait until thread has exited
@@ -513,7 +507,6 @@
size_t size, unsigned msg_flags)
{
int sent,ok;
- sigset_t old_blocked;
ERR_IF(!h) return FALSE;
ERR_IF(!size) return FALSE;
@@ -522,11 +515,8 @@
h->command = cpu_to_be16(cmd);
h->length = cpu_to_be16(size-sizeof(Drbd_Header));
- old_blocked = block_sigs_but(DRBD_SHUTDOWNSIGMASK);
sent = drbd_send(mdev,sock,h,size,msg_flags);
- restore_old_sigset(old_blocked);
- D_ASSERT(sent == size);
ok = ( sent == size );
if(!ok) {
ERR("short sent %s size=%d sent=%d\n",
@@ -542,6 +532,8 @@
Drbd_Packet_Cmd cmd, Drbd_Header* h, size_t size)
{
int ok;
+ sigset_t old_blocked;
+
if (sock == mdev->data.socket) {
down(&mdev->data.mutex);
spin_lock(&mdev->send_task_lock);
@@ -550,7 +542,9 @@
} else
down(&mdev->meta.mutex);
+ old_blocked = block_sigs_but(DRBD_SHUTDOWNSIGMASK);
ok = _drbd_send_cmd(mdev,sock,cmd,h,size,0);
+ restore_old_sigset(old_blocked);
if (sock == mdev->data.socket) {
up(&mdev->data.mutex);
@@ -572,10 +566,14 @@
Drbd_Packet_Cmd cmd, Drbd_Header* h, size_t size)
{
int ok;
+ sigset_t old_blocked;
+
struct semaphore *mutex = sock == mdev->meta.socket ?
&mdev->meta.mutex : &mdev->data.mutex;
if (down_trylock(mutex)) return -EAGAIN;
+ old_blocked = block_sigs_but(DRBD_SHUTDOWNSIGMASK);
ok = _drbd_send_cmd(mdev,sock,cmd,h,size, MSG_DONTWAIT);
+ restore_old_sigset(old_blocked);
up (mutex);
return ok;
}
@@ -794,6 +792,8 @@
int ok;
sigset_t old_blocked;
Drbd_Data_Packet p;
+ Drbd_Header ioh;
+
ERR_IF(!req || !req->master_bio) return FALSE;
@@ -824,22 +824,12 @@
* so all sorts of processes may end up here.
* They may be interrupted by DRBD_SIGKILL in response to
* ioctl or some other "connection loast" event.
-
- * FIXME
- * unfortunatly this may well be a user process like dd,
- * and interupted by a user signal.
- * (in 0.6.x this was handled with the "app_got_sig" cludge)
-
- * THINK
- * maybe we should block all signals (so we don't need to
- * wory about user signals), and use force_sig() instead
- * of drbd_queue_signal.
*
* we also should replace all "LOCK(); sigemptyset(); UNLOCK();"
* with flush_signals(); ...
*/
- old_blocked = block_sigs_but(sigmask(DRBD_SIGKILL));
+ old_blocked = block_sigs_but(0);
down(&mdev->data.mutex);
spin_lock(&mdev->send_task_lock);
mdev->send_task=current;
@@ -849,9 +839,15 @@
_drbd_send_barrier(mdev);
tl_add(mdev,req);
req->rq_status |= RQ_DRBD_IN_TL;
+
ok = (drbd_send(mdev,mdev->data.socket,&p,sizeof(p),MSG_MORE) == sizeof(p))
&& _drbd_send_zc_bio(mdev,&req->private_bio);
+ if(test_and_clear_bit(ISSUE_IO_HINT,&mdev->flags)) {
+ _drbd_send_cmd(mdev,mdev->data.socket,WriteHint,&ioh,
+ sizeof(ioh),0);
+ }
+
spin_lock(&mdev->send_task_lock);
mdev->send_task=NULL;
spin_unlock(&mdev->send_task_lock);
@@ -1038,13 +1034,11 @@
WRITE_HINT for an other device (which is in primary state).
This could lead to a distributed deadlock!!
- To avoid the deadlock we requeue the WRITE_HINT.
+ To avoid the deadlock we set the ISSUE_IO_HINT bit and
+ it will be sent after the current data block.
UPDATE:
since "dontwait" this would no longer deadlock, but probably
create a useless loop echoing WriteHints back and forth ...
- THINK:
- Why not set an other bit, so the write hint is sent asap
- by one of our threads?
*/
for (i = 0; i < minor_count; i++) {
@@ -1054,14 +1048,11 @@
}
}
- // THINK: sock or msock ?
- if (drbd_send_cmd_dontwait(mdev,mdev->data.socket,WriteHint,&h,sizeof(h))==1){
- clear_bit(WRITE_HINT_QUEUED, &mdev->flags);
- } else {
- if(mdev->cstate < Connected) {
- clear_bit(WRITE_HINT_QUEUED, &mdev->flags);
- } else queue_task(&mdev->write_hint_tq, &tq_disk);
+ if (drbd_send_cmd_dontwait(mdev,mdev->data.socket,WriteHint,&h,
+ sizeof(h)) != 1){
+ set_bit(ISSUE_IO_HINT,&mdev->flags);
}
+ clear_bit(WRITE_HINT_QUEUED, &mdev->flags);
}
#else
@@ -1080,7 +1071,7 @@
if (drbd_send_cmd_dontwait(mdev,mdev->data.socket,WriteHint,&h,
sizeof(h)) != 1) {
- WARN("Have to drop sending of an io-hint\n");
+ set_bit(ISSUE_IO_HINT,&mdev->flags);
}
spin_lock_irq(q->queue_lock);
@@ -2041,22 +2032,6 @@
void drbd_md_inc(drbd_dev *mdev, enum MetaDataIndex order)
{
mdev->gen_cnt[order]++;
-}
-
-// XXX maybe use one of the functions from signal.h
-void drbd_queue_signal(int signal,struct task_struct *task)
-{
- unsigned long flags;
-
- read_lock(&tasklist_lock);
- if (task) {
- LOCK_SIGMASK(task,flags);
- sigaddset(&task->pending.signal, signal);
- RECALC_SIGPENDING(task);
- UNLOCK_SIGMASK(task,flags);
- if (task->state & TASK_INTERRUPTIBLE) wake_up_process(task);
- }
- read_unlock(&tasklist_lock);
}
#ifdef SIGHAND_HACK
===================================================================
RCS file: /var/lib/cvs/drbd/drbd/drbd/drbd_receiver.c,v
retrieving revision 1.97.2.116
retrieving revision 1.97.2.117
diff -u -3 -r1.97.2.116 -r1.97.2.117
--- drbd_receiver.c 6 Mar 2004 09:31:27 -0000 1.97.2.116
+++ drbd_receiver.c 6 Mar 2004 13:28:13 -0000 1.97.2.117
@@ -1535,7 +1535,7 @@
struct task_struct *task;
spin_lock(&mdev->send_task_lock);
if((task=mdev->send_task)) {
- drbd_queue_signal(DRBD_SIG, task);
+ force_sig(DRBD_SIG, task);
spin_unlock(&mdev->send_task_lock);
down(&mdev->data.mutex);
break;
@@ -1600,16 +1600,14 @@
drbdd(mdev);
drbd_disconnect(mdev);
if (thi->t_state == Exiting) break;
- else {
+ if (thi->t_state == Restarting) {
unsigned long flags;
+ thi->t_state = Running;
+
LOCK_SIGMASK(current,flags);
sigemptyset(¤t->pending.signal);
RECALC_SIGPENDING(current);
UNLOCK_SIGMASK(current,flags);
-
- if (thi->t_state != Restarting)
- ERR("unexpected thread state: %d\n", thi->t_state);
- thi->t_state = Running;
}
}