Ticket #8420: 0001-Fix-8420-NetFS-does-not-compile-with-DEBUG.patch

src/add-ons/kernel/file_systems/netfs/client/RootVolume.cpp

@@ -152 +152 @@
                 || serverNameLen == sizeof(params->serverName)) {
                 return B_BAD_VALUE;
             }
-            PRINT(("RootVolume::IOCtl(): NET_FS_IOCTL_ADD_SERVER: `%s'\n",
-                params->serverName));
+            PRINT("RootVolume::IOCtl(): NET_FS_IOCTL_ADD_SERVER: "
+                "`%s'\n", params->serverName);
 
             // get the server address
             NetAddress netAddress;
@@ -178 +178 @@
                 || serverNameLen == sizeof(params->serverName)) {
                 return B_BAD_VALUE;
             }
-            PRINT(("RootVolume::IOCtl(): NET_FS_IOCTL_REMOVE_SERVER: `%s'\n",
-                params->serverName));
+            PRINT("RootVolume::IOCtl(): NET_FS_IOCTL_REMOVE_SERVER:"
+                " `%s'\n", params->serverName);
 
             // get the server volume
             ServerVolume* serverVolume = _GetServerVolume(params->serverName);
@@ -193 +193 @@
             return B_OK;
         }
         default:
-            PRINT(("RootVolume::IOCtl(): unknown ioctl: %d\n", cmd));
+            PRINT("RootVolume::IOCtl(): unknown ioctl: %d\n", cmd);
             return B_BAD_VALUE;
             break;
     }
@@ -207 +207 @@
 void
 RootVolume::ServerAdded(ExtendedServerInfo* serverInfo)
 {
-PRINT(("RootVolume::ServerAdded(%s)\n", serverInfo->GetServerName()));
+    PRINT("RootVolume::ServerAdded(%s)\n", serverInfo->GetServerName());
     // check, if the server does already exist
     ServerVolume* serverVolume = _GetServerVolume(serverInfo->GetAddress());
     if (serverVolume) {
-        WARN(("RootVolume::ServerAdded(): WARNING: ServerVolume does already "
-            "exist.\n"));
+        WARN("RootVolume::ServerAdded(): WARNING: ServerVolume does "
+            "already exist.\n");
         serverVolume->PutVolume();
         return;
     }
@@ -258 +258 @@
 RootVolume::ServerUpdated(ExtendedServerInfo* oldInfo,
     ExtendedServerInfo* newInfo)
 {
-PRINT(("RootVolume::ServerUpdated(%s)\n", newInfo->GetServerName()));
+    PRINT("RootVolume::ServerUpdated(%s)\n", newInfo->GetServerName());
     // get the volume
     ServerVolume* serverVolume = _GetServerVolume(newInfo->GetAddress());
     if (!serverVolume)
@@ -273 +273 @@
 void
 RootVolume::ServerRemoved(ExtendedServerInfo* serverInfo)
 {
-PRINT(("RootVolume::ServerRemoved(%s)\n", serverInfo->GetServerName()));
+    PRINT("RootVolume::ServerRemoved(%s)\n", serverInfo->GetServerName());
     // get the volume
     ServerVolume* serverVolume = _GetServerVolume(serverInfo->GetAddress());
     if (!serverVolume)

src/add-ons/kernel/file_systems/netfs/client/ServerManager.cpp

@@ -303 +303 @@
         ssize_t bytesRead = recvfrom(fBroadcastListenerSocket, &message,
             sizeof(message), 0, (sockaddr*)&addr, &addrSize);
         if (bytesRead < 0) {
-            PRINT(("ServerManager::_BroadcastListener(): recvfrom() failed: %s\n",
-                strerror(errno)));
+            PRINT("ServerManager::_BroadcastListener(): recvfrom() "
+                "failed: %s\n", strerror(errno));
             continue;
         }
 
         // check message size, magic, and protocol version
         if (bytesRead != sizeof(BroadcastMessage)) {
-            PRINT(("ServerManager::_BroadcastListener(): received %ld bytes, but "
-                "it should be %lu\n", bytesRead, sizeof(BroadcastMessage)));
+            PRINT("ServerManager::_BroadcastListener(): received "
+                "%ld bytes, but it should be %lu\n", bytesRead,
+                sizeof(BroadcastMessage));
             continue;
         }
         if (message.magic != B_HOST_TO_BENDIAN_INT32(BROADCAST_MESSAGE_MAGIC)) {
-            PRINT(("ServerManager::_BroadcastListener(): message has bad "
-                "magic.\n"));
+            PRINT("ServerManager::_BroadcastListener(): message has"
+                " bad magic.\n");
             continue;
         }
         if (message.protocolVersion
             != (int32)B_HOST_TO_BENDIAN_INT32(NETFS_PROTOCOL_VERSION)) {
-            PRINT(("ServerManager::_BroadcastListener(): protocol version "
-                "does not match: %lu vs. %d.\n",
-                B_BENDIAN_TO_HOST_INT32(message.protocolVersion),
-                NETFS_PROTOCOL_VERSION));
+            PRINT("ServerManager::_BroadcastListener(): protocol "
+                "version does not match: %lu vs. %d.\n",
+                B_BENDIAN_TO_HOST_INT32(
+                    message.protocolVersion),
+                NETFS_PROTOCOL_VERSION);
             continue;
         }
 

src/add-ons/kernel/file_systems/netfs/client/ServerVolume.cpp

@@ -77 +77 @@
         fLock.Unlock();
 
         if (remove) {
-            PRINT(("  removing share: %s\n", name));
+            PRINT("  removing share: %s\n", name);
             if (Volume* volume = GetChildVolume(name)) {
                 volume->SetUnmounting(true);
                 volume->PutVolume();
@@ -101 +101 @@
         if (volume) {
             volume->PutVolume();
         } else {
-            PRINT(("  adding share: %s\n", shareInfo->GetShareName()));
+            PRINT("  adding share: %s\n",
+                shareInfo->GetShareName());
             status_t error = _AddShare(shareInfo);
             if (error != B_OK) {
                 ERROR("ServerVolume::SetServerInfo(): ERROR: Failed to add "

src/add-ons/kernel/file_systems/netfs/client/ShareVolume.cpp

@@ -353 +353 @@
     int32 count = fNodes->Size();
     if (count == 0)
         return;
-PRINT(("  %ld nodes to remove\n", count));
+    PRINT("  %ld nodes to remove\n", count);
     vnode_id* ids = new(std::nothrow) vnode_id[count];
     if (!ids) {
         ERROR("ShareVolume::PrepareToUnmount(): ERROR: Insufficient memory to "
@@ -395 +395 @@
     for (int32 i = 0; i < count; i++) {
         Node* node;
         if (GetVNode(ids[i], &node) == B_OK) {
-PRINT(("  removing node %lld\n", ids[i]));
+            PRINT("  removing node %lld\n", ids[i]);
             Volume::RemoveVNode(ids[i]);
             PutVNode(ids[i]);
         }
@@ -1166 +1166 @@
     ObjectDeleter<Request> replyDeleter(reply);
     if (reply->error != B_OK)
 {
-PRINT(("OpenDir() failed: node: %lld, remote: (%ld, %lld)\n",
-node->GetID(), node->GetRemoteID().volumeID, node->GetRemoteID().nodeID));
+        PRINT("OpenDir() failed: node: %lld, remote: (%ld, %lld)\n",
+            node->GetID(), node->GetRemoteID().volumeID,
+            node->GetRemoteID().nodeID);
         RETURN_ERROR(reply->error);
 }
 
@@ -2017 +2018 @@
     buffer->d_ino = localNodeID;
 
     *countRead = 1;
-PRINT(("  entry: d_dev: %ld, d_pdev: %ld, d_ino: %Ld, d_pino: %Ld, "
-"d_reclen: %hu, d_name: `%s'\n",
-buffer->d_dev, buffer->d_pdev, buffer->d_ino, buffer->d_pino,
-buffer->d_reclen, buffer->d_name));
+    PRINT("  entry: d_dev: %ld, d_pdev: %ld, d_ino: %Ld, d_pino: %Ld, "
+        "d_reclen: %hu, d_name: `%s'\n", buffer->d_dev, buffer->d_pdev,
+        buffer->d_ino, buffer->d_pino, buffer->d_reclen,
+        buffer->d_name);
     return B_OK;
 }
 
@@ -2171 +2172 @@
     status_t error = _GetLocalNodeID(request->directoryID, &vnida, true);
     if (error == B_OK)
         error = _GetLocalNodeID(request->nodeID, &vnidc, true);
-PRINT(("ShareVolume::_HandleEntryCreatedRequest(): error: 0x%lx, name: \"%s\", dir: %lld (remote: (%ld, %lld)), node: %lld (remote: (%ld, %lld))\n", error, name, vnida, request->directoryID.volumeID, request->directoryID.nodeID, vnidc, request->nodeID.volumeID, request->nodeID.nodeID));
+        PRINT("ShareVolume::_HandleEntryCreatedRequest(): error: 0x%lx,"
+            " name: \"%s\", dir: %lld (remote: (%ld, %lld)), node:"
+            " %lld (remote: (%ld, %lld))\n", error, name, vnida,
+            request->directoryID.volumeID,
+            request->directoryID.nodeID, vnidc,
+            request->nodeID.volumeID, request->nodeID.nodeID);
 
     // send notifications / do additional processing
     if (request->queryUpdate) {
@@ -2363 +2369 @@
         fVolumeManager->RemoveNodeID(localID);
         return error;
     }
-PRINT(("ShareVolume(%ld): added node ID mapping: local: %lld -> "
-"remote: (%ld, %lld)\n", fID, localID, remoteID.volumeID, remoteID.nodeID));
+    PRINT("ShareVolume(%ld): added node ID mapping: local: %lld -> "
+        "remote: (%ld, %lld)\n", fID, localID, remoteID.volumeID,
+        remoteID.nodeID);
 
     *_localID = localID;
     return B_OK;
@@ -2396 +2403 @@
 
     // remove from ID maps
     NodeID remoteID = fRemoteNodeIDs->Get(localID);
-PRINT(("ShareVolume::_RemoveLocalNodeID(%lld): remote: (%ld, %lld)\n", localID, remoteID.volumeID, remoteID.nodeID));
+    PRINT("ShareVolume::_RemoveLocalNodeID(%lld): remote: (%ld, %lld)\n",
+        localID, remoteID.volumeID, remoteID.nodeID);
     fRemoteNodeIDs->Remove(localID);
     fLocalNodeIDs->Remove(remoteID);
 
@@ -2463 +2471 @@
             delete node;
             return error;
         }
-PRINT(("ShareVolume: added node: %lld: remote: (%ld, %lld), localID: %lld\n",
-node->GetID(), node->GetRemoteID().volumeID, node->GetRemoteID().nodeID,
-localID));
+        PRINT("ShareVolume: added node: %lld: remote: (%ld, %lld),"
+            " localID: %lld\n", node->GetID(),
+            node->GetRemoteID().volumeID,
+            node->GetRemoteID().nodeID, localID);
     }
 
     if (_node)
@@ -3023 +3032 @@
     // get the share name
     const char* share = shareInfo->GetShareName();
 
-PRINT(("ShareVolume::_MountShare(%s, %s)\n", server, share));
+    PRINT("ShareVolume::_MountShare(%s, %s)\n", server, share);
     // init a connection to the authentication server
     AuthenticationServer authenticationServer;
     error = authenticationServer.InitCheck();
@@ -3094 +3103 @@
         fLocalNodeIDs->Remove(fRootNode->GetRemoteID());
         RETURN_ERROR(error);
     }
-PRINT(("ShareVolume::_MountShare(): root node: local: %lld, remote: (%ld, %lld)\n", fRootNode->GetID(), fRootNode->GetRemoteID().volumeID, fRootNode->GetRemoteID().nodeID));
+    PRINT("ShareVolume::_MountShare(): root node: local: %lld, remote: "
+        "(%ld, %lld)\n", fRootNode->GetID(),
+        fRootNode->GetRemoteID().volumeID,
+        fRootNode->GetRemoteID().nodeID);
 
     // Add ourselves to the server connection, so that we can receive
     // node monitoring events. There a race condition: We might already

src/add-ons/kernel/file_systems/netfs/client/Volume.cpp

@@ -172 +172 @@
     nspace_id nsida, nspace_id nsidb, vnode_id vnida, vnode_id vnidb,
     vnode_id vnidc, const char *name)
 {
-PRINT(("Volume::SendNotification(%ld, %ld, 0x%lx, 0x%lx, %ld, %ld, %lld, %lld, %lld, \"%s\")\n", port, token, what, op, nsida, nsidb, vnida, vnidb, vnidc, name));
+    PRINT("Volume::SendNotification(%ld, %ld, 0x%lx, 0x%lx, %ld, %ld, %lld,"
+        " %lld, %lld, \"%s\")\n", port, token, what, op, nsida, nsidb,
+        vnida, vnidb, vnidc, name);
     return send_notification(port, token, what, op, nsida, nsidb, vnida,
         vnidb, vnidc, name);
 }

src/add-ons/kernel/file_systems/netfs/client/VolumeManager.cpp

@@ -333 +333 @@
     {
         AutoLocker<Locker> locker(this);
         if (volume->ReleaseReference() && volume->IsRemoved()) {
-PRINT(("VolumeManager::PutVolume(%p): Removed volume unreferenced. "
-"Unmounting...\n", volume));
+            PRINT("VolumeManager::PutVolume(%p): Removed volume "
+                "unreferenced. Unmounting...\n", volume);
             // remove from volume set -- now noone can get a reference to it
             // anymore
             fVolumes->Remove(volume);

src/add-ons/kernel/file_systems/netfs/client/netfs.cpp

@@ -224 +224 @@
 {
     VolumeManager* volumeManager = (VolumeManager*)ns;
 
-    PRINT(("netfs_unmount()\n"));
+    PRINT("netfs_unmount()\n");
 
     volumeManager->UnmountRootVolume();
     delete volumeManager;
@@ -233 +233 @@
         ObjectTracker::ExitDefault();
     #endif
 
-    PRINT(("netfs_unmount() done\n"));
+    PRINT("netfs_unmount() done\n");
 
     exit_debugging();
     return B_OK;
@@ -250 +250 @@
     Volume* volume = volumeManager->GetRootVolume();
     VolumePutter _(volume);
 
-    PRINT(("netfs_sync(%p)\n", ns));
+    PRINT("netfs_sync(%p)\n", ns);
 
     status_t error = B_BAD_VALUE;
     if (volume)
         error = volume->Sync();
 
-    PRINT(("netfs_sync() done: %lx \n", error));
+    PRINT("netfs_sync() done: %lx \n", error);
 
     return error;
 }
@@ -272 +272 @@
     Volume* volume = volumeManager->GetRootVolume();
     VolumePutter _(volume);
 
-    PRINT(("netfs_read_fs_stat(%p, %p)\n", ns, info));
+    PRINT("netfs_read_fs_stat(%p, %p)\n", ns, info);
 
     status_t error = B_BAD_VALUE;
     if (volume)
         error = volume->ReadFSStat(info);
 
-    PRINT(("netfs_read_fs_stat() done: %lx \n", error));
+    PRINT("netfs_read_fs_stat() done: %lx \n", error);
 
     return error;
 }
@@ -294 +294 @@
     Volume* volume = volumeManager->GetRootVolume();
     VolumePutter _(volume);
 
-    PRINT(("netfs_write_fs_stat(%p, %p, %ld)\n", ns, info, mask));
+    PRINT("netfs_write_fs_stat(%p, %p, %ld)\n", ns, info, mask);
 
     status_t error = B_BAD_VALUE;
     if (volume)
         error = volume->WriteFSStat(info, mask);
 
-    PRINT(("netfs_write_fs_stat() done: %lx \n", error));
+    PRINT("netfs_write_fs_stat() done: %lx \n", error);
 
     return error;
 }
@@ -319 +319 @@
     Volume* volume = volumeManager->GetVolume(vnid);
     VolumePutter _(volume);
 
-    PRINT(("netfs_read_vnode(%p, %Ld, %d, %p)\n", ns, vnid, reenter, node));
+    PRINT("netfs_read_vnode(%p, %Ld, %d, %p)\n", ns, vnid, reenter, node);
 
     status_t error = B_BAD_VALUE;
     if (volume)
         error = volume->ReadVNode(vnid, reenter, (Node**)node);
 
-    PRINT(("netfs_read_vnode() done: (%lx, %p)\n", error, *node));
+    PRINT("netfs_read_vnode() done: (%lx, %p)\n", error, *node);
 
     return error;
 }
@@ -371 +371 @@
 netfs_fsync(void *ns, void *_node)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_fsync(%p, %p)\n", ns, node));
+    PRINT("netfs_fsync(%p, %p)\n", ns, node);
     status_t error = node->GetVolume()->FSync(node);
-    PRINT(("netfs_fsync() done: %lx\n", error));
+    PRINT("netfs_fsync() done: %lx\n", error);
     return error;
 }
 
@@ -385 +385 @@
 netfs_read_stat(void *ns, void *_node, struct stat *st)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_read_stat(%p, %p, %p)\n", ns, node, st));
+    PRINT("netfs_read_stat(%p, %p, %p)\n", ns, node, st);
     status_t error = node->GetVolume()->ReadStat(node, st);
-    PRINT(("netfs_read_stat() done: %lx\n", error));
+    PRINT("netfs_read_stat() done: %lx\n", error);
     return error;
 }
 
@@ -397 +397 @@
 netfs_write_stat(void *ns, void *_node, struct stat *st, long mask)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_write_stat(%p, %p, %p, %ld)\n", ns, node, st, mask));
+    PRINT("netfs_write_stat(%p, %p, %p, %ld)\n", ns, node, st, mask);
     status_t error = node->GetVolume()->WriteStat(node, st, mask);
-    PRINT(("netfs_write_stat() done: %lx\n", error));
+    PRINT("netfs_write_stat() done: %lx\n", error);
     return error;
 }
 
@@ -409 +409 @@
 netfs_access(void *ns, void *_node, int mode)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_access(%p, %p, %d)\n", ns, node, mode));
+    PRINT("netfs_access(%p, %p, %d)\n", ns, node, mode);
     status_t error = node->GetVolume()->Access(node, mode);
-    PRINT(("netfs_access() done: %lx\n", error));
+    PRINT("netfs_access() done: %lx\n", error);
     return error;
 }
 
@@ -425 +425 @@
     vnode_id *vnid, void **cookie)
 {
     Node* dir = (Node*)_dir;
-    PRINT(("netfs_create(%p, %p, `%s', %d, %d, %p, %p)\n", ns, dir,
-        name, openMode, mode, vnid, cookie));
+    PRINT("netfs_create(%p, %p, `%s', %d, %d, %p, %p)\n", ns, dir,
+        name, openMode, mode, vnid, cookie);
     status_t error = dir->GetVolume()->Create(dir, name, openMode, mode, vnid,
         cookie);
-    PRINT(("netfs_create() done: (%lx, %Ld, %p)\n", error, *vnid,
-        *cookie));
+    PRINT("netfs_create() done: (%lx, %Ld, %p)\n", error, *vnid,
+        *cookie);
     return error;
 }
 
@@ -440 +440 @@
 netfs_open(void *ns, void *_node, int openMode, void **cookie)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_open(%p, %p, %d)\n", ns, node, openMode));
+    PRINT("netfs_open(%p, %p, %d)\n", ns, node, openMode);
     status_t error = node->GetVolume()->Open(node, openMode, cookie);
-    PRINT(("netfs_open() done: (%lx, %p)\n", error, *cookie));
+    PRINT("netfs_open() done: (%lx, %p)\n", error, *cookie);
     return error;
 }
 
@@ -452 +452 @@
 netfs_close(void *ns, void *_node, void *cookie)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_close(%p, %p, %p)\n", ns, node, cookie));
+    PRINT("netfs_close(%p, %p, %p)\n", ns, node, cookie);
     status_t error = node->GetVolume()->Close(node, cookie);
-    PRINT(("netfs_close() done: %lx\n", error));
+    PRINT("netfs_close() done: %lx\n", error);
     return error;
 }
 
@@ -464 +464 @@
 netfs_free_cookie(void *ns, void *_node, void *cookie)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_free_cookie(%p, %p, %p)\n", ns, node, cookie));
+    PRINT("netfs_free_cookie(%p, %p, %p)\n", ns, node, cookie);
     status_t error = node->GetVolume()->FreeCookie(node, cookie);
-    PRINT(("netfs_free_cookie() done: %lx\n", error));
+    PRINT("netfs_free_cookie() done: %lx\n", error);
     return error;
 }
 
@@ -477 +477 @@
     size_t *bufferSize)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_read(%p, %p, %p, %Ld, %p, %lu)\n", ns, node, cookie, pos,
-        buffer, *bufferSize));
+    PRINT("netfs_read(%p, %p, %p, %Ld, %p, %lu)\n", ns, node, cookie, pos,
+        buffer, *bufferSize);
     status_t error = node->GetVolume()->Read(node, cookie, pos, buffer,
         *bufferSize, bufferSize);
-    PRINT(("netfs_read() done: (%lx, %lu)\n", error, *bufferSize));
+    PRINT("netfs_read() done: (%lx, %lu)\n", error, *bufferSize);
     return error;
 }
 
@@ -492 +492 @@
     const void *buffer, size_t *bufferSize)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_write(%p, %p, %p, %Ld, %p, %lu)\n", ns, node, cookie, pos,
-        buffer, *bufferSize));
+    PRINT("netfs_write(%p, %p, %p, %Ld, %p, %lu)\n", ns, node, cookie, pos,
+        buffer, *bufferSize);
     status_t error = node->GetVolume()->Write(node, cookie, pos, buffer,
         *bufferSize, bufferSize);
-    PRINT(("netfs_write() done: (%lx, %lu)\n", error, *bufferSize));
+    PRINT("netfs_write() done: (%lx, %lu)\n", error, *bufferSize);
     return error;
 }
 
@@ -507 +507 @@
     size_t bufferSize)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_ioctl(%p, %p, %p, %d, %p, %lu)\n", ns, node, cookie, cmd,
-        buffer, bufferSize));
+    PRINT("netfs_ioctl(%p, %p, %p, %d, %p, %lu)\n", ns, node, cookie, cmd,
+        buffer, bufferSize);
     status_t error = node->GetVolume()->IOCtl(node, cookie, cmd, buffer,
         bufferSize);
-    PRINT(("netfs_ioctl() done: (%lx)\n", error));
+    PRINT("netfs_ioctl() done: (%lx)\n", error);
     return error;
 }
 
@@ -537 +537 @@
 {
     Node* dir = (Node*)_dir;
     Node* node = (Node*)_node;
-    PRINT(("netfs_link(%p, %p, `%s', %p)\n", ns, dir, name, node));
+    PRINT("netfs_link(%p, %p, `%s', %p)\n", ns, dir, name, node);
     status_t error = dir->GetVolume()->Link(dir, name, node);
-    PRINT(("netfs_link() done: (%lx)\n", error));
+    PRINT("netfs_link() done: (%lx)\n", error);
     return error;
 }
 
@@ -549 +549 @@
 netfs_unlink(void *ns, void *_dir, const char *name)
 {
     Node* dir = (Node*)_dir;
-    PRINT(("netfs_unlink(%p, %p, `%s')\n", ns, dir, name));
+    PRINT("netfs_unlink(%p, %p, `%s')\n", ns, dir, name);
     status_t error = dir->GetVolume()->Unlink(dir, name);
-    PRINT(("netfs_unlink() done: (%lx)\n", error));
+    PRINT("netfs_unlink() done: (%lx)\n", error);
     return error;
 }
 
@@ -561 +561 @@
 netfs_symlink(void *ns, void *_dir, const char *name, const char *path)
 {
     Node* dir = (Node*)_dir;
-    PRINT(("netfs_symlink(%p, %p, `%s', `%s')\n", ns, dir, name, path));
+    PRINT("netfs_symlink(%p, %p, `%s', `%s')\n", ns, dir, name, path);
     status_t error = dir->GetVolume()->Symlink(dir, name, path);
-    PRINT(("netfs_symlink() done: (%lx)\n", error));
+    PRINT("netfs_symlink() done: (%lx)\n", error);
     return error;
 }
 
@@ -573 +573 @@
 netfs_read_link(void *ns, void *_node, char *buffer, size_t *bufferSize)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_read_link(%p, %p, %p, %lu)\n", ns, node, buffer,
-        *bufferSize));
+    PRINT("netfs_read_link(%p, %p, %p, %lu)\n", ns, node, buffer,
+        *bufferSize);
     status_t error = node->GetVolume()->ReadLink(node, buffer, *bufferSize,
         bufferSize);
-    PRINT(("netfs_read_link() done: (%lx, %lu)\n", error, *bufferSize));
+    PRINT("netfs_read_link() done: (%lx, %lu)\n", error, *bufferSize);
     return error;
 }
 
@@ -589 +589 @@
 {
     Node* oldDir = (Node*)_oldDir;
     Node* newDir = (Node*)_newDir;
-    PRINT(("netfs_rename(%p, %p, `%s', %p, `%s')\n", ns, oldDir, oldName,
-        newDir, newName));
+    PRINT("netfs_rename(%p, %p, `%s', %p, `%s')\n", ns, oldDir, oldName,
+        newDir, newName);
     status_t error = oldDir->GetVolume()->Rename(oldDir, oldName,
         newDir, newName);
-    PRINT(("netfs_rename() done: (%lx)\n", error));
+    PRINT("netfs_rename() done: (%lx)\n", error);
     return error;
 }
 
@@ -606 +606 @@
 netfs_mkdir(void *ns, void *_dir, const char *name, int mode)
 {
     Node* dir = (Node*)_dir;
-    PRINT(("netfs_mkdir(%p, %p, `%s', %d)\n", ns, dir, name, mode));
+    PRINT("netfs_mkdir(%p, %p, `%s', %d)\n", ns, dir, name, mode);
     status_t error = dir->GetVolume()->MkDir(dir, name, mode);
-    PRINT(("netfs_mkdir() done: (%lx)\n", error));
+    PRINT("netfs_mkdir() done: (%lx)\n", error);
     return error;
 }
 
@@ -618 +618 @@
 netfs_rmdir(void *ns, void *_dir, const char *name)
 {
     Node* dir = (Node*)_dir;
-    PRINT(("netfs_rmdir(%p, %p, `%s')\n", ns, dir, name));
+    PRINT("netfs_rmdir(%p, %p, `%s')\n", ns, dir, name);
     status_t error = dir->GetVolume()->RmDir(dir, name);
-    PRINT(("netfs_rmdir() done: (%lx)\n", error));
+    PRINT("netfs_rmdir() done: (%lx)\n", error);
     return error;
 }
 
@@ -630 +630 @@
 netfs_open_dir(void *ns, void *_node, void **cookie)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_open_dir(%p, %p)\n", ns, node));
+    PRINT("netfs_open_dir(%p, %p)\n", ns, node);
     status_t error = node->GetVolume()->OpenDir(node, cookie);
-    PRINT(("netfs_open_dir() done: (%lx, %p)\n", error, *cookie));
+    PRINT("netfs_open_dir() done: (%lx, %p)\n", error, *cookie);
     return error;
 }
 
@@ -642 +642 @@
 netfs_close_dir(void *ns, void *_node, void *cookie)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_close_dir(%p, %p, %p)\n", ns, node, cookie));
+    PRINT("netfs_close_dir(%p, %p, %p)\n", ns, node, cookie);
     status_t error = node->GetVolume()->CloseDir(node, cookie);
-    PRINT(("netfs_close_dir() done: %lx\n", error));
+    PRINT("netfs_close_dir() done: %lx\n", error);
     return error;
 }
 
@@ -654 +654 @@
 netfs_free_dir_cookie(void *ns, void *_node, void *cookie)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_free_dir_cookie(%p, %p, %p)\n", ns, node, cookie));
+    PRINT("netfs_free_dir_cookie(%p, %p, %p)\n", ns, node, cookie);
     status_t error = node->GetVolume()->FreeDirCookie(node, cookie);
-    PRINT(("netfs_free_dir_cookie() done: %lx \n", error));
+    PRINT("netfs_free_dir_cookie() done: %lx \n", error);
     return error;
 }
 
@@ -667 +667 @@
     struct dirent *buffer, size_t bufferSize)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_read_dir(%p, %p, %p, %ld, %p, %lu)\n", ns, node, cookie,
-        *count, buffer, bufferSize));
+    PRINT("netfs_read_dir(%p, %p, %p, %ld, %p, %lu)\n", ns, node, cookie,
+        *count, buffer, bufferSize);
     status_t error = node->GetVolume()->ReadDir(node, cookie, buffer,
         bufferSize, *count, count);
-    PRINT(("netfs_read_dir() done: (%lx, %ld)\n", error, *count));
+    PRINT("netfs_read_dir() done: (%lx, %ld)\n", error, *count);
     #if DEBUG
         dirent* entry = buffer;
         for (int32 i = 0; i < *count; i++) {
@@ -681 +681 @@
             int nameLen = strnlen(entry->d_name, B_FILE_NAME_LENGTH - 1);
             strncpy(name, entry->d_name, nameLen);
             name[nameLen] = '\0';
-            PRINT(("  entry: d_dev: %ld, d_pdev: %ld, d_ino: %Ld, d_pino: %Ld, "
-                "d_reclen: %hu, d_name: `%s'\n",
-                entry->d_dev, entry->d_pdev, entry->d_ino, entry->d_pino,
-                entry->d_reclen, name));
+            PRINT("  entry: d_dev: %ld, d_pdev: %ld, d_ino: %Ld,"
+                " d_pino: %Ld, d_reclen: %hu, d_name: `%s'\n",
+                entry->d_dev, entry->d_pdev, entry->d_ino,
+                entry->d_pino, entry->d_reclen, name);
             entry = (dirent*)((char*)entry + entry->d_reclen);
         }
     #endif
@@ -698 +698 @@
 netfs_rewind_dir(void *ns, void *_node, void *cookie)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_rewind_dir(%p, %p, %p)\n", ns, node, cookie));
+    PRINT("netfs_rewind_dir(%p, %p, %p)\n", ns, node, cookie);
     status_t error = node->GetVolume()->RewindDir(node, cookie);
-    PRINT(("netfs_rewind_dir() done: %lx\n", error));
+    PRINT("netfs_rewind_dir() done: %lx\n", error);
     return error;
 }
 
@@ -711 +711 @@
     char **resolvedPath, vnode_id *vnid)
 {
     Node* dir = (Node*)_dir;
-    PRINT(("netfs_walk(%p, %p, `%s', %p, %p)\n", ns, dir,
-        entryName, resolvedPath, vnid));
+    PRINT("netfs_walk(%p, %p, `%s', %p, %p)\n", ns, dir,
+        entryName, resolvedPath, vnid);
     status_t error = dir->GetVolume()->Walk(dir, entryName, resolvedPath, vnid);
-    PRINT(("netfs_walk() done: (%lx, `%s', %Ld)\n", error,
-        (resolvedPath ? *resolvedPath : NULL), *vnid));
+    PRINT("netfs_walk() done: (%lx, `%s', %Ld)\n", error,
+        (resolvedPath ? *resolvedPath : NULL), *vnid);
     return error;
 }
 
@@ -728 +728 @@
 netfs_open_attrdir(void *ns, void *_node, void **cookie)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_open_attrdir(%p, %p)\n", ns, node));
+    PRINT("netfs_open_attrdir(%p, %p)\n", ns, node);
     status_t error = node->GetVolume()->OpenAttrDir(node, cookie);
-    PRINT(("netfs_open_attrdir() done: (%lx, %p)\n", error, *cookie));
+    PRINT("netfs_open_attrdir() done: (%lx, %p)\n", error, *cookie);
     return error;
 }
 
@@ -740 +740 @@
 netfs_close_attrdir(void *ns, void *_node, void *cookie)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_close_attrdir(%p, %p, %p)\n", ns, node, cookie));
+    PRINT("netfs_close_attrdir(%p, %p, %p)\n", ns, node, cookie);
     status_t error = node->GetVolume()->CloseAttrDir(node, cookie);
-    PRINT(("netfs_close_attrdir() done: (%lx)\n", error));
+    PRINT("netfs_close_attrdir() done: (%lx)\n", error);
     return error;
 }
 
@@ -752 +752 @@
 netfs_free_attrdir_cookie(void *ns, void *_node, void *cookie)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_free_attrdir_cookie(%p, %p, %p)\n", ns, node, cookie));
+    PRINT("netfs_free_attrdir_cookie(%p, %p, %p)\n", ns, node, cookie);
     status_t error = node->GetVolume()->FreeAttrDirCookie(node, cookie);
-    PRINT(("netfs_free_attrdir_cookie() done: (%lx)\n", error));
+    PRINT("netfs_free_attrdir_cookie() done: (%lx)\n", error);
     return error;
 }
 
@@ -765 +765 @@
     struct dirent *buffer, size_t bufferSize)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_read_attrdir(%p, %p, %p, %ld, %p, %lu)\n", ns, node,
-        cookie, *count, buffer, bufferSize));
+    PRINT("netfs_read_attrdir(%p, %p, %p, %ld, %p, %lu)\n", ns, node,
+        cookie, *count, buffer, bufferSize);
     status_t error = node->GetVolume()->ReadAttrDir(node, cookie, buffer,
         bufferSize, *count, count);
-    PRINT(("netfs_read_attrdir() done: (%lx, %ld)\n", error, *count));
+    PRINT("netfs_read_attrdir() done: (%lx, %ld)\n", error, *count);
     return error;
 }
 
@@ -779 +779 @@
 netfs_rewind_attrdir(void *ns, void *_node, void *cookie)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_rewind_attrdir(%p, %p, %p)\n", ns, node, cookie));
+    PRINT("netfs_rewind_attrdir(%p, %p, %p)\n", ns, node, cookie);
     status_t error = node->GetVolume()->RewindAttrDir(node, cookie);
-    PRINT(("netfs_rewind_attrdir() done: (%lx)\n", error));
+    PRINT("netfs_rewind_attrdir() done: (%lx)\n", error);
     return error;
 }
 
@@ -792 +792 @@
     void *buffer, size_t *bufferSize, off_t pos)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_read_attr(%p, %p, `%s', %d, %p, %lu, %Ld)\n", ns, node,
-        name, type, buffer, *bufferSize, pos));
+    PRINT("netfs_read_attr(%p, %p, `%s', %d, %p, %lu, %Ld)\n", ns, node,
+        name, type, buffer, *bufferSize, pos);
     status_t error = node->GetVolume()->ReadAttr(node, name, type, pos, buffer,
         *bufferSize, bufferSize);
-    PRINT(("netfs_read_attr() done: (%lx, %ld)\n", error, *bufferSize));
+    PRINT("netfs_read_attr() done: (%lx, %ld)\n", error, *bufferSize);
     return error;
 }
 
@@ -807 +807 @@
     const void *buffer, size_t *bufferSize, off_t pos)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_write_attr(%p, %p, `%s', %d, %p, %lu, %Ld)\n", ns, node,
-        name, type, buffer, *bufferSize, pos));
+    PRINT("netfs_write_attr(%p, %p, `%s', %d, %p, %lu, %Ld)\n", ns, node,
+        name, type, buffer, *bufferSize, pos);
     status_t error = node->GetVolume()->WriteAttr(node, name, type, pos, buffer,
         *bufferSize, bufferSize);
-    PRINT(("netfs_write_attr() done: (%lx, %ld)\n", error, *bufferSize));
+    PRINT("netfs_write_attr() done: (%lx, %ld)\n", error, *bufferSize);
     return error;
 }
 
@@ -821 +821 @@
 netfs_remove_attr(void *ns, void *_node, const char *name)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_remove_attr(%p, %p, `%s')\n", ns, node, name));
+    PRINT("netfs_remove_attr(%p, %p, `%s')\n", ns, node, name);
     status_t error = node->GetVolume()->RemoveAttr(node, name);
-    PRINT(("netfs_remove_attr() done: (%lx)\n", error));
+    PRINT("netfs_remove_attr() done: (%lx)\n", error);
     return error;
 }
 
@@ -834 +834 @@
     const char *newName)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_rename_attr(%p, %p, `%s', `%s')\n", ns, node, oldName,
-        newName));
+    PRINT("netfs_rename_attr(%p, %p, `%s', `%s')\n", ns, node, oldName,
+        newName);
     status_t error = node->GetVolume()->RenameAttr(node, oldName, newName);
-    PRINT(("netfs_rename_attr() done: (%lx)\n", error));
+    PRINT("netfs_rename_attr() done: (%lx)\n", error);
     return error;
 }
 
@@ -848 +848 @@
     struct attr_info *attrInfo)
 {
     Node* node = (Node*)_node;
-    PRINT(("netfs_stat_attr(%p, %p, `%s', %p)\n", ns, node, name,
-        attrInfo));
+    PRINT("netfs_stat_attr(%p, %p, `%s', %p)\n", ns, node, name,
+        attrInfo);
     status_t error = node->GetVolume()->StatAttr(node, name, attrInfo);
-    PRINT(("netfs_stat_attr() done: (%lx)\n", error));
+    PRINT("netfs_stat_attr() done: (%lx)\n", error);
     return error;
 }
 
@@ -868 +868 @@
     Volume* volume = volumeManager->GetRootVolume();
     VolumePutter _(volume);
 
-    PRINT(("netfs_open_query(%p, `%s', %lu, %ld, %ld, %p)\n", ns,
-        queryString, flags, port, token, cookie));
+    PRINT("netfs_open_query(%p, `%s', %lu, %ld, %ld, %p)\n", ns,
+        queryString, flags, port, token, cookie);
 
     status_t error = B_BAD_VALUE;
     if (volume) {
@@ -877 +877 @@
             (QueryIterator**)cookie);
     }
 
-    PRINT(("netfs_open_query() done: (%lx, %p)\n", error, *cookie));
+    PRINT("netfs_open_query() done: (%lx, %p)\n", error, *cookie);
     return error;
 }
 
@@ -886 +886 @@
 int
 netfs_close_query(void *ns, void *cookie)
 {
-    PRINT(("netfs_close_query(%p, %p)\n", ns, cookie));
+    PRINT("netfs_close_query(%p, %p)\n", ns, cookie);
 
     status_t error = B_OK;
     // no-op: we don't use this hook
 
-    PRINT(("netfs_close_query() done: (%lx)\n", error));
+    PRINT("netfs_close_query() done: (%lx)\n", error);
     return error;
 }
 
@@ -903 +903 @@
     VolumeManager* volumeManager = (VolumeManager*)ns;
     QueryIterator* iterator = (QueryIterator*)cookie;
 
-    PRINT(("netfs_free_query_cookie(%p, %p)\n", ns, cookie));
+    PRINT("netfs_free_query_cookie(%p, %p)\n", ns, cookie);
 
     status_t error = B_OK;
     volumeManager->GetQueryManager()->PutIterator(iterator);
 
-    PRINT(("netfs_free_query_cookie() done: (%lx)\n", error));
+    PRINT("netfs_free_query_cookie() done: (%lx)\n", error);
     return error;
 }
 
@@ -923 +923 @@
     QueryIterator* iterator = (QueryIterator*)cookie;
     VolumePutter _(volume);
 
-    PRINT(("netfs_read_query(%p, %p, %ld, %p, %lu)\n", ns, cookie,
-        *count, buffer, bufferSize));
+    PRINT("netfs_read_query(%p, %p, %ld, %p, %lu)\n", ns, cookie,
+        *count, buffer, bufferSize);
 
     status_t error = B_BAD_VALUE;
     if (volume) {
@@ -932 +932 @@
         *count, count);
     }
 
-    PRINT(("netfs_read_query() done: (%lx, %ld)\n", error, *count));
+    PRINT("netfs_read_query() done: (%lx, %ld)\n", error, *count);
     return error;
 }
 

src/add-ons/kernel/file_systems/netfs/server/ClientConnection.cpp

@@ -1612 +1612 @@
     }
 else {
 if (directory)
-PRINT(("OpenDir() failed: client volume: %ld, node: (%ld, %lld)\n",
-volume->GetID(), directory->GetVolumeID(), directory->GetID()));
+PRINT("OpenDir() failed: client volume: %ld, node: (%ld, %lld)\n",
+volume->GetID(), directory->GetVolumeID(), directory->GetID());
 }
 
     managerLocker.Unlock();
@@ -1679 +1679 @@
     }
 
 if (result == B_OK) {
-PRINT(("ReadDir: (%ld, %lld)\n", request->volumeID, directory->GetID()));
+    PRINT("ReadDir: (%ld, %lld)\n", request->volumeID, directory->GetID());
 }
 
     // rewind, if requested
@@ -1713 +1713 @@
 //reply.entryInfo.directoryID,
 //reply.entryInfo.nodeID, reply.entryInfo.name.GetString()));
 if (directory) {
-PRINT(("ReadDir done: volume: %ld, (%ld, %lld) -> (%lx, %ld)\n",
+PRINT("ReadDir done: volume: %ld, (%ld, %lld) -> (%lx, %ld)\n",
 volume->GetID(), directory->GetVolumeID(), directory->GetID(), result,
-reply.entryInfos.CountElements()));
+reply.entryInfos.CountElements());
 }
 
     managerLocker.Unlock();
@@ -1789 +1789 @@
 
     // send the reply
     reply.error = result;
-PRINT(("Walk: (%ld, %lld, `%s') -> (%lx, (%ld, %lld), `%s')\n",
-request->nodeID.volumeID, request->nodeID.nodeID, request->name.GetString(),
-result, reply.entryInfo.nodeInfo.st.st_dev, reply.entryInfo.nodeInfo.st.st_ino,
-reply.linkPath.GetString()));
+    PRINT("Walk: (%ld, %lld, `%s') -> (%lx, (%ld, %lld), `%s')\n",
+        request->nodeID.volumeID, request->nodeID.nodeID,
+        request->name.GetString(), result,
+        reply.entryInfo.nodeInfo.st.st_dev,
+        reply.entryInfo.nodeInfo.st.st_ino, reply.linkPath.GetString());
     return GetChannel()->SendRequest(&reply);
 }
 
@@ -1854 +1855 @@
 
     // send the reply
     reply.error = result;
-PRINT(("MultiWalk: (%ld, %lld, %ld) -> (%lx, %ld)\n",
-request->nodeID.volumeID, request->nodeID.nodeID, count,
-result, reply.entryInfos.CountElements()));
+    PRINT("MultiWalk: (%ld, %lld, %ld) -> (%lx, %ld)\n",
+        request->nodeID.volumeID, request->nodeID.nodeID, count,
+        result, reply.entryInfos.CountElements());
     return GetChannel()->SendRequest(&reply);
 }
 
@@ -2434 +2435 @@
             break;
         if (countRead == 0)
             break;
-PRINT(("  query entry: %ld, %lld, \"%s\"\n", dirEntry->d_pdev, dirEntry->d_pino, dirEntry->d_name));
+        PRINT("  query entry: %ld, %lld, \"%s\"\n",
+            dirEntry->d_pdev, dirEntry->d_pino, dirEntry->d_name);
 
         VolumeManagerLocker managerLocker;
         VolumeManager* volumeManager = VolumeManager::GetDefault();
@@ -2473 +2475 @@
     // send the reply
     reply.error = result;
     reply.count = countRead;
-PRINT(("ReadQuery: (%lx, %ld, dir: (%ld, %lld), node: (%ld, %lld, `%s')\n",
-reply.error, reply.count, reply.entryInfo.directoryID.volumeID,
-reply.entryInfo.directoryID.nodeID, reply.entryInfo.nodeInfo.st.st_dev,
-reply.entryInfo.nodeInfo.st.st_ino, reply.entryInfo.name.GetString()));
+    PRINT("ReadQuery: (%lx, %ld, dir: (%ld, %lld), node: (%ld, %lld, `%s')"
+        "\n", reply.error, reply.count,
+        reply.entryInfo.directoryID.volumeID,
+        reply.entryInfo.directoryID.nodeID,
+        reply.entryInfo.nodeInfo.st.st_dev,
+        reply.entryInfo.nodeInfo.st.st_ino,
+        reply.entryInfo.name.GetString());
     return GetChannel()->SendRequest(&reply);
 }
 
@@ -2570 +2575 @@
             event->opcode);
         return;
     }
-PRINT(("ClientConnection::ProcessQueryEvent(): event: %p, type: %s: directory: (%ld, %lld)\n", event, typeid(event).name(), volumeID, directoryID));
+    PRINT("ClientConnection::ProcessQueryEvent(): event: %p, type: %s:"
+        " directory: (%ld, %lld)\n", event, typeid(event).name(),
+        volumeID, directoryID);
 
     // create an array for the IDs of the client volumes a found entry may
     // reside on

src/add-ons/kernel/file_systems/netfs/server/NetFSServer.cpp

@@ -764 +764 @@
 void
 NetFSServer::ClientConnectionClosed(ClientConnection* connection, bool broken)
 {
-PRINT(("NetFSServer::ClientConnectionClosed(%d)\n", broken));
+    PRINT("NetFSServer::ClientConnectionClosed(%d)\n", broken);
     if (!connection)
         return;
     AutoLocker<Locker> locker(fLock);

src/add-ons/kernel/file_systems/netfs/server/NodeMonitor.cpp

@@ -102 +102 @@
             error = watch_node(&ref, flags, this);
     }
 if (error == B_OK) {
-PRINT(("NodeMonitor: started watching node: (%ld, %lld)\n", ref.device,
-ref.node));
+    PRINT("NodeMonitor: started watching node: (%ld, %lld)\n", ref.device,
+        ref.node);
 }
     return error;
 }
@@ -112 +112 @@
 status_t
 NodeMonitor::StopWatching(const node_ref& ref)
 {
-PRINT(("NodeMonitor: stopped watching node: (%ld, %lld)\n", ref.device,
-ref.node));
+    PRINT("NodeMonitor: stopped watching node: (%ld, %lld)\n", ref.device,
+        ref.node);
     return watch_node(&ref, B_STOP_WATCHING, this);
 }
 

src/add-ons/kernel/file_systems/netfs/server/VolumeManager.cpp

@@ -719 +719 @@
     Entry* entry = GetEntry(volumeID, directoryID, name);
     if (!entry) {
         // entry not known yet: create it
-PRINT(("VolumeManager::LoadEntry(%ld, %lld, `%s')\n", volumeID, directoryID,
-name));
+        PRINT("VolumeManager::LoadEntry(%ld, %lld, `%s')\n", volumeID,
+            directoryID, name);
 
         // get the volume
         Volume* volume = GetVolume(volumeID, true);
@@ -791 +791 @@
     if (!queryDomain || !queryString || !handle)
         return B_BAD_VALUE;
     bool liveQuery = (flags & B_LIVE_QUERY);
-PRINT(("VolumeManager::OpenQuery(%p, \"%s\", 0x%lx, %ld, %ld)\n", queryDomain, queryString, flags, remotePort, remoteToken));
+    PRINT("VolumeManager::OpenQuery(%p, \"%s\", 0x%lx, %ld, %ld)\n",
+        queryDomain, queryString, flags, remotePort, remoteToken);
 
     // allocate the handle
     QueryHandle* queryHandle = new(std::nothrow) QueryHandle(remotePort,
@@ -826 +827 @@
         // branches of the FS tree and don't have common nodes.
         if (!queryDomain->QueryDomainIntersectsWith(volume))
             continue;
-PRINT(("VolumeManager::OpenQuery(): adding Query for volume %ld\n", volume->GetID()));
+        PRINT("VolumeManager::OpenQuery(): adding Query for volume %ld"
+            "\n", volume->GetID());
 
         // create the query for this volume
         BVolume bVolume(volume->GetID());
@@ -1708 +1710 @@
         event->nodeID = st.st_ino;
         if (Volume* volume = GetVolume(st.st_dev)) {
             if (volume->GetRootID() == st.st_ino) {
-                PRINT(("Mount point for volume %ld renamed\n",
-                    volume->GetID()));
+                PRINT("Mount point for volume %ld renamed\n",
+                    volume->GetID());
             }
         }
     }

src/add-ons/kernel/file_systems/netfs/shared/InsecureConnection.cpp

@@ -161 +161 @@
     // open the remaining channels
     int32 allChannels = upStreamChannels + downStreamChannels;
     for (int32 i = 1; i < allChannels; i++) {
-PRINT(("  creating channel %ld\n", i));
+        PRINT("  creating channel %ld\n", i);
         // open the channel
         error = _OpenClientChannel(serverAddr, port, &channel);
         if (error != B_OK)
@@ -292 +292 @@
             }
             RETURN_ERROR(error);
         }
-PRINT(("  accepting channel %ld\n", i));
+        PRINT("  accepting channel %ld\n", i);
         // create a channel
         channel = new(std::nothrow) InsecureChannel(channelFD);
         if (!channel) {

src/add-ons/kernel/file_systems/netfs/shared/RequestChannel.cpp

@@ -161 +161 @@
 {
     if (!request)
         RETURN_ERROR(B_BAD_VALUE);
-PRINT(("%p->RequestChannel::SendRequest(): request: %p, type: %s\n", this, request, typeid(*request).name()));
+    PRINT("%p->RequestChannel::SendRequest(): request: %p, type: %s\n", this, request, typeid(*request).name());
 
     // get request size
     int32 size;
@@ -245 +245 @@
 
     requestDeleter.Detach();
     *_request = request;
-PRINT(("%p->RequestChannel::ReceiveRequest(): request: %p, type: %s\n", this, request, typeid(*request).name()));
+    PRINT("%p->RequestChannel::ReceiveRequest(): request: %p, type: %s\n", this, request, typeid(*request).name());
     return B_OK;
 }
 

src/add-ons/kernel/file_systems/netfs/shared/RequestDumper.cpp

@@ -24 +24 @@
 void
 RequestDumper::DumpRequest(Request* request)
 {
-    PRINT(("request: %s\n", typeid(*request).name()));
+    PRINT("request: %s\n", typeid(*request).name());
     fIndentationLevel++;
     request->ShowAround(this);
     fIndentationLevel--;
@@ -34 +34 @@
 void
 RequestDumper::Visit(RequestMember* member, bool& data)
 {
-    PRINT(("%sbool:   %s\n", _Indentation(), (data ? "true" : "false")));
+    PRINT("%sbool:   %s\n", _Indentation(), (data ? "true" : "false"));
 }
 
 // Visit
 void
 RequestDumper::Visit(RequestMember* member, int8& data)
 {
-    PRINT(("%sint8:   %d\n", _Indentation(), (int)data));
+    PRINT("%sint8:   %d\n", _Indentation(), (int)data);
 }
 
 // Visit
 void
 RequestDumper::Visit(RequestMember* member, uint8& data)
 {
-    PRINT(("%suint8:  %d\n", _Indentation(), (int)data));
+    PRINT("%suint8:  %d\n", _Indentation(), (int)data);
 }
 
 // Visit
 void
 RequestDumper::Visit(RequestMember* member, int16& data)
 {
-    PRINT(("%sint16:  %d\n", _Indentation(), (int)data));
+    PRINT("%sint16:  %d\n", _Indentation(), (int)data);
 }
 
 // Visit
 void
 RequestDumper::Visit(RequestMember* member, uint16& data)
 {
-    PRINT(("%suint16: %d\n", _Indentation(), (int)data));
+    PRINT("%suint16: %d\n", _Indentation(), (int)data);
 }
 
 // Visit
 void
 RequestDumper::Visit(RequestMember* member, int32& data)
 {
-    PRINT(("%sint32:  %ld\n", _Indentation(), data));
+    PRINT("%sint32:  %ld\n", _Indentation(), data);
 }
 
 // Visit
 void
 RequestDumper::Visit(RequestMember* member, uint32& data)
 {
-    PRINT(("%suint32: %lu\n", _Indentation(), data));
+    PRINT("%suint32: %lu\n", _Indentation(), data);
 }
 
 // Visit
 void
 RequestDumper::Visit(RequestMember* member, int64& data)
 {
-    PRINT(("%sint64:  %lld\n", _Indentation(), data));
+    PRINT("%sint64:  %lld\n", _Indentation(), data);
 }
 
 // Visit
 void
 RequestDumper::Visit(RequestMember* member, uint64& data)
 {
-    PRINT(("%suint64: %llu\n", _Indentation(), data));
+    PRINT("%suint64: %llu\n", _Indentation(), data);
 }
 
 // Visit
 void
 RequestDumper::Visit(RequestMember* member, Data& data)
 {
-    PRINT(("%sdata:    %p (%ld bytes)\n", _Indentation(), data.GetData(),
-        data.GetSize()));
+    PRINT("%sdata:    %p (%ld bytes)\n", _Indentation(), data.GetData(),
+        data.GetSize());
 }
 
 // Visit
 void
 RequestDumper::Visit(RequestMember* member, StringData& data)
 {
-    PRINT(("%sstring: \"%s\" (%p, %ld bytes)\n", _Indentation(),
-        data.GetString(), data.GetString(), data.GetSize()));
+    PRINT("%sstring: \"%s\" (%p, %ld bytes)\n", _Indentation(),
+        data.GetString(), data.GetString(), data.GetSize());
 }
 
 // Visit
 void
 RequestDumper::Visit(RequestMember* member, RequestMember& subMember)
 {
-    PRINT(("%ssubmember:\n", _Indentation()));
+    PRINT("%ssubmember:\n", _Indentation());
 
     fIndentationLevel++;
     subMember.ShowAround(this);
@@ -125 +125 @@
 RequestDumper::Visit(RequestMember* member,
     FlattenableRequestMember& subMember)
 {
-    PRINT(("%sflattenable: %s\n", _Indentation(), typeid(subMember).name()));
+    PRINT("%sflattenable: %s\n", _Indentation(), typeid(subMember).name());
 }
 
 // _Indentation