Ticket #5591: ThreadedFileWriter-deadlock.patch

libs/libmythtv/ThreadedFileWriter.cpp

@@ -210 +210 @@
     if (count == 0)
         return 0;
 
-    bool first = true;
+    uint bytes, remaining, iobound_cnt = 0;
+    bool first;
 
+    if (count > tfw_buf_size)
+    {
+        VERBOSE(VB_IMPORTANT, LOC + 
+                QString("WARNING: count(%1), tfw_buf_size(%2)")
+                .arg(count).arg(tfw_buf_size));
+    }
+
     // Qt4 requires a QMutex as a parameter...
     // not sure if this is the best solution.  Mutex Must be locked before wait.
     QMutex mutex;
     mutex.lock();
 
-    while (count > BufFree())
+    for (remaining = count; remaining; )
     {
-        if (first)
+        first = true;
+
+        bytes = BufFree() < remaining ? BufFree() : remaining;
+
+        while (BufFree() == 0)
         {
-            VERBOSE(VB_IMPORTANT, LOC_ERR + "Write() -- IOBOUND begin " + 
-                    QString("cnt(%1) free(%2)").arg(count).arg(BufFree()));
-            first = false;
+            if (first)
+            {
+                ++iobound_cnt;
+                VERBOSE(VB_IMPORTANT, LOC_ERR + "Write() -- IOBOUND begin " + 
+                        QString("bytes(%1) free(%2) size(%3) cnt(%4)")
+                        .arg(bytes).arg(BufFree())
+                        .arg(tfw_buf_size).arg(iobound_cnt));
+                first = false;
+            }
+            
+            bufferWroteData.wait(&mutex, 10000);
         }
+        if (!first)
+            VERBOSE(VB_IMPORTANT, LOC_ERR + "Write() -- IOBOUND end");
+        
+        if (no_writes)
+            return 0;
+        
+        if ((wpos + bytes) > tfw_buf_size)
+        {
+            int first_chunk_size = tfw_buf_size - wpos;
+            int second_chunk_size = bytes - first_chunk_size;
+            memcpy(buf + wpos, data, first_chunk_size );
+            memcpy(buf, (char *)data + first_chunk_size, second_chunk_size );
+        }
+        else
+        {
+            memcpy(buf + wpos, data, bytes);
+        }
 
-        bufferWroteData.wait(&mutex, 100);
-    }
-    if (!first)
-        VERBOSE(VB_IMPORTANT, LOC_ERR + "Write() -- IOBOUND end");
+        buflock.lock();
+        wpos = (wpos + bytes) % tfw_buf_size;
+        buflock.unlock();
 
-    if (no_writes)
-        return 0;
+        bufferHasData.wakeAll();
 
-    if ((wpos + count) > tfw_buf_size)
-    {
-        int first_chunk_size = tfw_buf_size - wpos;
-        int second_chunk_size = count - first_chunk_size;
-        memcpy(buf + wpos, data, first_chunk_size );
-        memcpy(buf, (char *)data + first_chunk_size, second_chunk_size );
+        remaining -= bytes;
+        if (remaining)
+            bufferWroteData.wait(&mutex, 10000);
     }
-    else
-    {
-        memcpy(buf + wpos, data, count);
-    }
 
-    buflock.lock();
-    wpos = (wpos + count) % tfw_buf_size;
-    buflock.unlock();
-
-    bufferHasData.wakeAll();
-
     return count;
 }
 
@@ -464 +486 @@
     QMutexLocker locker(&buflock);
     return ((wpos >= rpos) ? (rpos + tfw_buf_size) : rpos) - wpos - 1;
 }
-