1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
#include "integrity.h"
#include "locks.h"
#include "image.h"
#include "globals.h"
#include "memlog.h"
#include "helper.h"
#include <pthread.h>
#include <stdlib.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <string.h>
#include <assert.h>
#include <sys/resource.h>
#define CHECK_QUEUE_SIZE 100
typedef struct
{
dnbd3_image_t * volatile image;
int volatile block;
} queue_entry;
static pthread_t thread;
static queue_entry checkQueue[CHECK_QUEUE_SIZE];
static pthread_mutex_t integrityQueueLock;
static pthread_cond_t queueSignal;
static volatile int queueLen = -1;
static volatile int bRunning = FALSE;
static void* integrity_main(void *data);
/**
* Initialize the integrity check thread
*/
void integrity_init()
{
assert( queueLen == -1 );
pthread_mutex_init( &integrityQueueLock, NULL );
pthread_cond_init( &queueSignal, NULL );
bRunning = TRUE;
if ( 0 != thread_create( &thread, NULL, &integrity_main, (void *)NULL ) ) {
bRunning = FALSE;
memlogf( "[WARNING] Could not start integrity check thread. Corrupted images will not be detected." );
return;
}
queueLen = 0;
}
void integrity_shutdown()
{
assert( queueLen != -1 );
printf( "[DEBUG] Shutting down integrity checker...\n" );
pthread_mutex_lock( &integrityQueueLock );
pthread_cond_signal( &queueSignal );
pthread_mutex_unlock( &integrityQueueLock );
thread_join( thread, NULL );
while ( bRunning )
usleep( 10000 );
pthread_mutex_destroy( &integrityQueueLock );
pthread_cond_destroy( &queueSignal );
printf( "[DEBUG] Integrity checker exited normally.\n" );
}
/**
* Schedule an integrity check on the given image for the given hash block.
* It is not checked whether the block is completely cached locally, so
* make sure it is before calling, otherwise it will result in falsely
* detected corruption.
*/
void integrity_check(dnbd3_image_t *image, int block)
{
int i, freeSlot = -1;
pthread_mutex_lock( &integrityQueueLock );
for (i = 0; i < queueLen; ++i) {
if ( freeSlot == -1 && checkQueue[i].image == NULL ) {
freeSlot = i;
} else if ( checkQueue[i].image == image && checkQueue[i].block == block ) {
pthread_mutex_unlock( &integrityQueueLock );
return;
}
}
if ( freeSlot == -1 ) {
if ( queueLen >= CHECK_QUEUE_SIZE ) {
pthread_mutex_unlock( &integrityQueueLock );
printf( "[DEBUG] Check queue full, discarding check request...\n" );
return;
}
freeSlot = queueLen++;
}
checkQueue[freeSlot].image = image;
checkQueue[freeSlot].block = block;
pthread_cond_signal( &queueSignal );
pthread_mutex_unlock( &integrityQueueLock );
}
static void* integrity_main(void *data)
{
int i;
uint8_t *buffer = NULL;
size_t bufferSize = 0;
setThreadName( "image-check" );
blockNoncriticalSignals();
#if defined(linux) || defined(__linux)
// Setting nice of this thread - this is not POSIX conforming, so check if other platforms support this.
// POSIX says that setpriority() should set the nice value of all threads belonging to the current process,
// but on linux you can do this per thread.
pid_t tid = syscall( SYS_gettid );
setpriority( PRIO_PROCESS, tid, 10 );
#endif
pthread_mutex_lock( &integrityQueueLock );
while ( !_shutdown ) {
if ( queueLen == 0 ) {
pthread_cond_wait( &queueSignal, &integrityQueueLock );
}
for (i = queueLen - 1; i >= 0; --i) {
if ( _shutdown ) break;
if ( checkQueue[i].image == NULL ) continue;
dnbd3_image_t * const image = image_lock( checkQueue[i].image );
checkQueue[i].image = NULL;
if ( image == NULL ) continue;
// We have the image. Call image_release() some time
if ( i + 1 == queueLen ) queueLen--;
spin_lock( &image->lock );
if ( image->crc32 != NULL && image->filesize != 0 ) {
int const blocks[2] = { checkQueue[i].block, -1 };
pthread_mutex_unlock( &integrityQueueLock );
const uint64_t fileSize = image->filesize;
const size_t required = IMGSIZE_TO_HASHBLOCKS(image->filesize) * sizeof(uint32_t);
if ( required > bufferSize ) {
bufferSize = required;
if ( buffer != NULL ) free( buffer );
buffer = malloc( bufferSize );
}
memcpy( buffer, image->crc32, required );
spin_unlock( &image->lock );
int fd = open( image->path, O_RDONLY );
if ( fd >= 0 ) {
if ( image_checkBlocksCrc32( fd, (uint32_t*)buffer, blocks, fileSize ) ) {
//printf( "[DEBUG] CRC check of block %d for %s succeeded :-)\n", blocks[0], image->lower_name );
} else {
memlogf( "[WARNING] Hash check for block %d of %s failed!", blocks[0], image->lower_name );
image_updateCachemap( image, blocks[0] * HASH_BLOCK_SIZE, (blocks[0] + 1) * HASH_BLOCK_SIZE, FALSE );
}
close( fd );
}
pthread_mutex_lock( &integrityQueueLock );
} else {
spin_unlock( &image->lock );
}
// Release :-)
image_release( image );
}
}
pthread_mutex_unlock( &integrityQueueLock );
if ( buffer != NULL ) free( buffer );
bRunning = FALSE;
return NULL ;
}
|
