SourceFormat Enforcement

[thirdparty/squid.git] / src / DiskIO / DiskThreads / aiops_win32.cc

diff --git a/src/DiskIO/DiskThreads/aiops_win32.cc b/src/DiskIO/DiskThreads/aiops_win32.cc
index 3b54357adc017c833629faf914e4fec37fb4f271..4e75cfd0794bd00d37d1b010e1e3c60709e54b48 100644 (file)
--- a/src/DiskIO/DiskThreads/aiops_win32.cc
+++ b/src/DiskIO/DiskThreads/aiops_win32.cc
@@ -34,7 +34,7 @@
  *
  */
 
-#include "squid-old.h"
+#include "squid.h"
 #include "squid_windows.h"
 #include "DiskIO/DiskThreads/CommIO.h"
 #include "DiskThreads.h"
@@ -122,7 +122,6 @@ static void squidaio_poll_queues(void);
 static squidaio_thread_t *threads = NULL;
 static int squidaio_initialised = 0;
 
-
 #define AIO_LARGE_BUFS  16384
 #define AIO_MEDIUM_BUFS        AIO_LARGE_BUFS >> 1
 #define AIO_SMALL_BUFS AIO_LARGE_BUFS >> 2
@@ -612,7 +611,7 @@ squidaio_queue_request(squidaio_request_t * request)
         if (++filter >= filter_limit) {
             filter_limit += filter;
             filter = 0;
-            debugs(43, 1, "squidaio_queue_request: WARNING - Queue congestion");
+            debugs(43, DBG_IMPORTANT, "squidaio_queue_request: WARNING - Queue congestion");
         }
     }
 
@@ -635,10 +634,10 @@ squidaio_queue_request(squidaio_request_t * request)
 
         if (squid_curtime >= (last_warn + 15) &&
                 squid_curtime >= (high_start + 5)) {
-            debugs(43, 1, "squidaio_queue_request: WARNING - Disk I/O overloading");
+            debugs(43, DBG_IMPORTANT, "squidaio_queue_request: WARNING - Disk I/O overloading");
 
             if (squid_curtime >= (high_start + 15))
-                debugs(43, 1, "squidaio_queue_request: Queue Length: current=" <<
+                debugs(43, DBG_IMPORTANT, "squidaio_queue_request: Queue Length: current=" <<
                        request_queue_len << ", high=" << queue_high <<
                        ", low=" << queue_low << ", duration=" <<
                        (long int) (squid_curtime - high_start));
@@ -651,10 +650,10 @@ squidaio_queue_request(squidaio_request_t * request)
 
     /* Warn if seriously overloaded */
     if (request_queue_len > RIDICULOUS_LENGTH) {
-        debugs(43, 0, "squidaio_queue_request: Async request queue growing uncontrollably!");
-        debugs(43, 0, "squidaio_queue_request: Syncing pending I/O operations.. (blocking)");
+        debugs(43, DBG_CRITICAL, "squidaio_queue_request: Async request queue growing uncontrollably!");
+        debugs(43, DBG_CRITICAL, "squidaio_queue_request: Syncing pending I/O operations.. (blocking)");
         squidaio_sync();
-        debugs(43, 0, "squidaio_queue_request: Synced");
+        debugs(43, DBG_CRITICAL, "squidaio_queue_request: Synced");
     }
 }                              /* squidaio_queue_request */
 
@@ -721,7 +720,6 @@ squidaio_cleanup_request(squidaio_request_t * requestp)
     squidaio_request_pool->free(requestp);
 }                              /* squidaio_cleanup_request */
 
-
 int
 squidaio_cancel(squidaio_result_t * resultp)
 {
@@ -739,7 +737,6 @@ squidaio_cancel(squidaio_result_t * resultp)
     return 1;
 }                              /* squidaio_cancel */
 
-
 int
 squidaio_open(const char *path, int oflag, mode_t mode, squidaio_result_t * resultp)
 {
@@ -767,7 +764,6 @@ squidaio_open(const char *path, int oflag, mode_t mode, squidaio_result_t * resu
     return 0;
 }
 
-
 static void
 squidaio_do_open(squidaio_request_t * requestp)
 {
@@ -775,7 +771,6 @@ squidaio_do_open(squidaio_request_t * requestp)
     requestp->err = errno;
 }
 
-
 int
 squidaio_read(int fd, char *bufp, size_t bufs, off_t offset, int whence, squidaio_result_t * resultp)
 {
@@ -806,7 +801,6 @@ squidaio_read(int fd, char *bufp, size_t bufs, off_t offset, int whence, squidai
     return 0;
 }
 
-
 static void
 squidaio_do_read(squidaio_request_t * requestp)
 {
@@ -821,7 +815,6 @@ squidaio_do_read(squidaio_request_t * requestp)
     requestp->err = errno;
 }
 
-
 int
 squidaio_write(int fd, char *bufp, size_t bufs, off_t offset, int whence, squidaio_result_t * resultp)
 {
@@ -852,7 +845,6 @@ squidaio_write(int fd, char *bufp, size_t bufs, off_t offset, int whence, squida
     return 0;
 }
 
-
 static void
 squidaio_do_write(squidaio_request_t * requestp)
 {
@@ -865,7 +857,6 @@ squidaio_do_write(squidaio_request_t * requestp)
     requestp->err = errno;
 }
 
-
 int
 squidaio_close(int fd, squidaio_result_t * resultp)
 {
@@ -888,19 +879,17 @@ squidaio_close(int fd, squidaio_result_t * resultp)
     return 0;
 }
 
-
 static void
 squidaio_do_close(squidaio_request_t * requestp)
 {
     if ((requestp->ret = close(requestp->fd)) < 0) {
-        debugs(43, 0, "squidaio_do_close: FD " << requestp->fd << ", errno " << errno);
+        debugs(43, DBG_CRITICAL, "squidaio_do_close: FD " << requestp->fd << ", errno " << errno);
         close(requestp->fd);
     }
 
     requestp->err = errno;
 }
 
-
 int
 
 squidaio_stat(const char *path, struct stat *sb, squidaio_result_t * resultp)
@@ -929,7 +918,6 @@ squidaio_stat(const char *path, struct stat *sb, squidaio_result_t * resultp)
     return 0;
 }
 
-
 static void
 squidaio_do_stat(squidaio_request_t * requestp)
 {
@@ -937,7 +925,6 @@ squidaio_do_stat(squidaio_request_t * requestp)
     requestp->err = errno;
 }
 
-
 int
 squidaio_unlink(const char *path, squidaio_result_t * resultp)
 {
@@ -961,7 +948,6 @@ squidaio_unlink(const char *path, squidaio_result_t * resultp)
     return 0;
 }
 
-
 static void
 squidaio_do_unlink(squidaio_request_t * requestp)
 {