From 367b07d54addf471636a7c5dc1bde320560c4f68 Mon Sep 17 00:00:00 2001 From: Pawel Dziepak Date: Wed, 11 Jul 2012 22:06:03 +0200 Subject: [PATCH] nfs4: Use more meaningful names in Connection and RPCServer --- .../kernel/file_systems/nfs4/Connection.cpp | 140 +++++++++--------- .../kernel/file_systems/nfs4/Connection.h | 31 ++-- .../kernel/file_systems/nfs4/RPCServer.cpp | 56 +++---- .../kernel/file_systems/nfs4/RPCServer.h | 28 ++-- 4 files changed, 129 insertions(+), 126 deletions(-) diff --git a/src/add-ons/kernel/file_systems/nfs4/Connection.cpp b/src/add-ons/kernel/file_systems/nfs4/Connection.cpp index 20e1c93ba2..10b576cced 100644 --- a/src/add-ons/kernel/file_systems/nfs4/Connection.cpp +++ b/src/add-ons/kernel/file_systems/nfs4/Connection.cpp @@ -24,41 +24,41 @@ bool -ServerAddress::operator==(const ServerAddress& x) +ServerAddress::operator==(const ServerAddress& address) { - return fAddress == x.fAddress && fPort == x.fPort - && fProtocol == x.fProtocol; + return fAddress == address.fAddress && fPort == address.fPort + && fProtocol == address.fProtocol; } bool -ServerAddress::operator<(const ServerAddress& x) +ServerAddress::operator<(const ServerAddress& address) { - return fAddress < x.fAddress || - (fAddress == x.fAddress && fPort < x.fPort) || - (fAddress == x.fAddress && fPort == x.fPort && - fProtocol < x.fProtocol); + return fAddress < address.fAddress || + (fAddress == address.fAddress && fPort < address.fPort) || + (fAddress == address.fAddress && fPort == address.fPort && + fProtocol < address.fProtocol); } ServerAddress& -ServerAddress::operator=(const ServerAddress& x) +ServerAddress::operator=(const ServerAddress& address) { - fAddress = x.fAddress; - fPort = x.fPort; - fProtocol = x.fProtocol; + fAddress = address.fAddress; + fPort = address.fPort; + fProtocol = address.fProtocol; return *this; } status_t -ServerAddress::ResolveName(const char* name, ServerAddress* addr) +ServerAddress::ResolveName(const char* name, ServerAddress* address) { - addr->fPort = 2049; - addr->fProtocol = IPPROTO_UDP; + address->fPort = 2049; + address->fProtocol = IPPROTO_UDP; struct in_addr iaddr; if (inet_aton(name, &iaddr) != 0) { - addr->fAddress = ntohl(iaddr.s_addr); + address->fAddress = ntohl(iaddr.s_addr); return B_OK; } @@ -70,9 +70,10 @@ ServerAddress::ResolveName(const char* name, ServerAddress* addr) addrinfo* current = ai; while (current != NULL) { if (current->ai_family == AF_INET) { - sockaddr_in* sin = reinterpret_cast(current->ai_addr); + sockaddr_in* sin = + reinterpret_cast(current->ai_addr); - addr->fAddress = ntohl(sin->sin_addr.s_addr); + address->fAddress = ntohl(sin->sin_addr.s_addr); freeaddrinfo(ai); return B_OK; @@ -86,52 +87,52 @@ ServerAddress::ResolveName(const char* name, ServerAddress* addr) } -Connection::Connection(const sockaddr_in& addr, int proto) +Connection::Connection(const sockaddr_in& address, int protocol) : fWaitCancel(create_sem(0, NULL)), - fSock(-1), - fProtocol(proto), - fServerAddress(addr) + fSocket(-1), + fProtocol(protocol), + fServerAddress(address) { - mutex_init(&fSockLock, NULL); + mutex_init(&fSocketLock, NULL); } -ConnectionStream::ConnectionStream(const sockaddr_in& addr, int proto) +ConnectionStream::ConnectionStream(const sockaddr_in& address, int protocol) : - Connection(addr, proto) + Connection(address, protocol) { } -ConnectionPacket::ConnectionPacket(const sockaddr_in& addr, int proto) +ConnectionPacket::ConnectionPacket(const sockaddr_in& address, int protocol) : - Connection(addr, proto) + Connection(address, protocol) { } Connection::~Connection() { - if (fSock != -1) - close(fSock); - mutex_destroy(&fSockLock); + if (fSocket != -1) + close(fSocket); + mutex_destroy(&fSocketLock); delete_sem(fWaitCancel); } status_t -Connection::GetLocalID(ServerAddress* addr) +Connection::GetLocalAddress(ServerAddress* address) { struct sockaddr_in saddr; - socklen_t slen = sizeof(addr); - status_t result = getsockname(fSock, (struct sockaddr*)&saddr, &slen); + socklen_t slen = sizeof(saddr); + status_t result = getsockname(fSocket, (struct sockaddr*)&saddr, &slen); if (result != B_OK) return result; - addr->fProtocol = fProtocol; - addr->fPort = ntohs(saddr.sin_port); - addr->fAddress = ntohl(saddr.sin_addr.s_addr); + address->fProtocol = fProtocol; + address->fPort = ntohs(saddr.sin_port); + address->fAddress = ntohl(saddr.sin_addr.s_addr); return B_OK; } @@ -152,12 +153,12 @@ ConnectionStream::Send(const void* buffer, uint32 size) // More than one threads may send data and ksend is allowed to send partial // data. Need a lock here. uint32 sent = 0; - mutex_lock(&fSockLock); + mutex_lock(&fSocketLock); do { - result = send(fSock, buf + sent, size + sizeof(uint32) - sent, 0); + result = send(fSocket, buf + sent, size + sizeof(uint32) - sent, 0); sent += result; } while (result > 0 && sent < size + sizeof(uint32)); - mutex_unlock(&fSockLock); + mutex_unlock(&fSocketLock); if (result < 0) { result = errno; free(buf); @@ -176,7 +177,7 @@ status_t ConnectionPacket::Send(const void* buffer, uint32 size) { // send on DGRAM sockets is atomic. No need to lock. - status_t result = send(fSock, buffer, size, 0); + status_t result = send(fSocket, buffer, size, 0); if (result < 0) return errno; @@ -185,7 +186,7 @@ ConnectionPacket::Send(const void* buffer, uint32 size) status_t -ConnectionStream::Receive(void** pbuffer, uint32* psize) +ConnectionStream::Receive(void** _buffer, uint32* _size) { status_t result; @@ -200,7 +201,7 @@ ConnectionStream::Receive(void** pbuffer, uint32* psize) object[0].type = B_OBJECT_TYPE_SEMAPHORE; object[0].events = B_EVENT_ACQUIRE_SEMAPHORE; - object[1].object = fSock; + object[1].object = fSocket; object[1].type = B_OBJECT_TYPE_FD; object[1].events = B_EVENT_READ; @@ -216,7 +217,7 @@ ConnectionStream::Receive(void** pbuffer, uint32* psize) // There is only one listener thread per connection. No need to lock. uint32 received = 0; do { - result = recv(fSock, &record_size + received, + result = recv(fSocket, &record_size + received, sizeof(record_size) - received, 0); received += result; } while (result > 0 && received < sizeof(record_size)); @@ -242,7 +243,7 @@ ConnectionStream::Receive(void** pbuffer, uint32* psize) received = 0; do { - result = recv(fSock, (uint8*)buffer + size + received, + result = recv(fSocket, (uint8*)buffer + size + received, record_size - received, 0); received += result; } while (result > 0 && received < sizeof(record_size)); @@ -256,15 +257,15 @@ ConnectionStream::Receive(void** pbuffer, uint32* psize) } while (!last_one); - *pbuffer = buffer; - *psize = size; + *_buffer = buffer; + *_size = size; return B_OK; } status_t -ConnectionPacket::Receive(void** pbuffer, uint32* psize) +ConnectionPacket::Receive(void** _buffer, uint32* _size) { status_t result; int32 size = MAX_PACKET_SIZE; @@ -278,7 +279,7 @@ ConnectionPacket::Receive(void** pbuffer, uint32* psize) object[0].type = B_OBJECT_TYPE_SEMAPHORE; object[0].events = B_EVENT_ACQUIRE_SEMAPHORE; - object[1].object = fSock; + object[1].object = fSocket; object[1].type = B_OBJECT_TYPE_FD; object[1].events = B_EVENT_READ; @@ -294,7 +295,7 @@ ConnectionPacket::Receive(void** pbuffer, uint32* psize) } while (true); // There is only one listener thread per connection. No need to lock. - size = recv(fSock, buffer, size, 0); + size = recv(fSocket, buffer, size, 0); if (size < 0) { result = errno; free(buffer); @@ -304,31 +305,31 @@ ConnectionPacket::Receive(void** pbuffer, uint32* psize) return ECONNABORTED; } - *pbuffer = buffer; - *psize = size; + *_buffer = buffer; + *_size = size; return B_OK; } status_t -Connection::Connect(Connection **pconn, const ServerAddress& id) +Connection::Connect(Connection **_connection, const ServerAddress& address) { struct sockaddr_in addr; memset(&addr, 0, sizeof(addr)); addr.sin_len = sizeof(struct sockaddr_in); addr.sin_family = AF_INET; - addr.sin_addr.s_addr = htonl(id.fAddress); - addr.sin_port = htons(id.fPort); + addr.sin_addr.s_addr = htonl(address.fAddress); + addr.sin_port = htons(address.fPort); Connection* conn; - switch (id.fProtocol) { + switch (address.fProtocol) { case IPPROTO_TCP: - conn = new(std::nothrow) ConnectionStream(addr, id.fProtocol); + conn = new(std::nothrow) ConnectionStream(addr, address.fProtocol); break; case IPPROTO_UDP: - conn = new(std::nothrow) ConnectionPacket(addr, id.fProtocol); + conn = new(std::nothrow) ConnectionPacket(addr, address.fProtocol); break; default: return B_BAD_VALUE; @@ -336,39 +337,39 @@ Connection::Connect(Connection **pconn, const ServerAddress& id) if (conn == NULL) return B_NO_MEMORY; - status_t result = conn->_Connect(); + status_t result = conn->Connect(); if (result != B_OK) { delete conn; return result; } - *pconn = conn; + *_connection = conn; return B_OK; } status_t -Connection::_Connect() +Connection::Connect() { switch (fProtocol) { case IPPROTO_TCP: - fSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + fSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); break; case IPPROTO_UDP: - fSock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + fSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); break; default: return B_BAD_VALUE; } - if (fSock < 0) + if (fSocket < 0) return errno; - status_t result = connect(fSock, (struct sockaddr*)&fServerAddress, + status_t result = connect(fSocket, (struct sockaddr*)&fServerAddress, fServerAddress.sin_len); if (result < 0) { result = errno; - close(fSock); + close(fSocket); return result; } @@ -380,9 +381,9 @@ status_t Connection::Reconnect() { release_sem(fWaitCancel); - close(fSock); + close(fSocket); acquire_sem(fWaitCancel); - return _Connect(); + return Connect(); } @@ -391,8 +392,7 @@ Connection::Disconnect() { release_sem(fWaitCancel); - int sock = fSock; - fSock = -1; - close(sock); + close(fSocket); + fSocket = -1; } diff --git a/src/add-ons/kernel/file_systems/nfs4/Connection.h b/src/add-ons/kernel/file_systems/nfs4/Connection.h index 2386f76715..d6f996a04d 100644 --- a/src/add-ons/kernel/file_systems/nfs4/Connection.h +++ b/src/add-ons/kernel/file_systems/nfs4/Connection.h @@ -20,36 +20,37 @@ struct ServerAddress { uint16 fPort; int fProtocol; - bool operator==(const ServerAddress& x); - bool operator<(const ServerAddress& x); + bool operator==(const ServerAddress& address); + bool operator<(const ServerAddress& address); - ServerAddress& operator=(const ServerAddress& x); + ServerAddress& operator=(const ServerAddress& address); static status_t ResolveName(const char* name, - ServerAddress* addr); + ServerAddress* address); }; class Connection { public: - static status_t Connect(Connection **conn, - const ServerAddress& id); + static status_t Connect(Connection **connection, + const ServerAddress& address); virtual ~Connection(); virtual status_t Send(const void* buffer, uint32 size) = 0; virtual status_t Receive(void** buffer, uint32* size) = 0; - status_t GetLocalID(ServerAddress* addr); + status_t GetLocalAddress(ServerAddress* address); status_t Reconnect(); void Disconnect(); protected: - Connection(const sockaddr_in& addr, int proto); - status_t _Connect(); + Connection(const sockaddr_in& address, + int protocol); + status_t Connect(); sem_id fWaitCancel; - int fSock; - mutex fSockLock; + int fSocket; + mutex fSocketLock; const int fProtocol; const sockaddr_in fServerAddress; @@ -57,8 +58,8 @@ protected: class ConnectionStream : public Connection { public: - ConnectionStream(const sockaddr_in& addr, - int proto); + ConnectionStream(const sockaddr_in& address, + int protocol); virtual status_t Send(const void* buffer, uint32 size); virtual status_t Receive(void** buffer, uint32* size); @@ -66,8 +67,8 @@ public: class ConnectionPacket : public Connection { public: - ConnectionPacket(const sockaddr_in& addr, - int proto); + ConnectionPacket(const sockaddr_in& address, + int protocol); virtual status_t Send(const void* buffer, uint32 size); virtual status_t Receive(void** buffer, uint32* size); diff --git a/src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp b/src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp index cf913d39ff..e13a36e276 100644 --- a/src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp +++ b/src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp @@ -35,14 +35,14 @@ RequestManager::~RequestManager() void -RequestManager::AddRequest(Request* req) +RequestManager::AddRequest(Request* request) { MutexLocker _(fLock); if (fQueueTail != NULL) - fQueueTail->fNext = req; + fQueueTail->fNext = request; else - fQueueHead = req; - fQueueTail = req; + fQueueHead = request; + fQueueTail = request; } @@ -72,10 +72,10 @@ RequestManager::FindRequest(uint32 xid) } -Server::Server(Connection* conn, ServerAddress* addr) +Server::Server(Connection* connection, ServerAddress* address) : - fConnection(conn), - fAddress(addr), + fConnection(connection), + fAddress(address), fPrivateData(NULL), fXID(rand() << 1) { @@ -164,19 +164,19 @@ Server::SendCallAsync(Call* call, Reply** reply, Request** request) status_t -Server::ResendCallAsync(Call* call, Request* req) +Server::ResendCallAsync(Call* call, Request* request) { if (fThreadError != B_OK) { - fRequests.FindRequest(req->fXID); - delete req; + fRequests.FindRequest(request->fXID); + delete request; return fThreadError; } XDR::WriteStream& stream = call->Stream(); status_t result = fConnection->Send(stream.Buffer(), stream.Size()); if (result != B_OK) { - fRequests.FindRequest(req->fXID); - delete req; + fRequests.FindRequest(request->fXID); + delete request; return result; } @@ -257,9 +257,9 @@ Server::_Listener() status_t -Server::_ListenerThreadStart(void* ptr) +Server::_ListenerThreadStart(void* object) { - Server* server = reinterpret_cast(ptr); + Server* server = reinterpret_cast(object); return server->_Listener(); } @@ -279,16 +279,16 @@ ServerManager::~ServerManager() status_t -ServerManager::Acquire(Server** pserv, const ServerAddress& id, - ProgramData* (*createPriv)(Server*)) +ServerManager::Acquire(Server** _server, const ServerAddress& address, + ProgramData* (*createPrivateData)(Server*)) { status_t result; MutexLocker locker(fLock); - ServerNode* node = _Find(id); + ServerNode* node = _Find(address); if (node != NULL) { node->fRefCount++; - *pserv = node->fServer; + *_server = node->fServer; return B_OK; } @@ -297,10 +297,10 @@ ServerManager::Acquire(Server** pserv, const ServerAddress& id, if (node == NULL) return B_NO_MEMORY; - node->fID = id; + node->fID = address; Connection* conn; - result = Connection::Connect(&conn, id); + result = Connection::Connect(&conn, address); if (result != B_OK) { delete node; return result; @@ -312,7 +312,7 @@ ServerManager::Acquire(Server** pserv, const ServerAddress& id, delete conn; return B_NO_MEMORY; } - node->fServer->SetPrivateData(createPriv(node->fServer)); + node->fServer->SetPrivateData(createPrivateData(node->fServer)); node->fRefCount = 1; node->fLeft = node->fRight = NULL; @@ -323,20 +323,20 @@ ServerManager::Acquire(Server** pserv, const ServerAddress& id, delete node->fServer; delete node; - *pserv = nd->fServer; + *_server = nd->fServer; return B_OK; } - *pserv = node->fServer; + *_server = node->fServer; return B_OK; } void -ServerManager::Release(Server* serv) +ServerManager::Release(Server* server) { MutexLocker _(fLock); - ServerNode* node = _Find(serv->ID()); + ServerNode* node = _Find(server->ID()); if (node != NULL) { node->fRefCount--; @@ -350,13 +350,13 @@ ServerManager::Release(Server* serv) ServerNode* -ServerManager::_Find(const ServerAddress& id) +ServerManager::_Find(const ServerAddress& address) { ServerNode* node = fRoot; while (node != NULL) { - if (node->fID == id) + if (node->fID == address) return node; - if (node->fID < id) + if (node->fID < address) node = node->fRight; else node = node->fLeft; diff --git a/src/add-ons/kernel/file_systems/nfs4/RPCServer.h b/src/add-ons/kernel/file_systems/nfs4/RPCServer.h index 3a4a7edd46..3a954b35cd 100644 --- a/src/add-ons/kernel/file_systems/nfs4/RPCServer.h +++ b/src/add-ons/kernel/file_systems/nfs4/RPCServer.h @@ -35,7 +35,7 @@ public: RequestManager(); ~RequestManager(); - void AddRequest(Request* req); + void AddRequest(Request* request); Request* FindRequest(uint32 xid); private: @@ -52,15 +52,17 @@ public: class Server { public: - Server(Connection* conn, - ServerAddress* addr); + Server(Connection* connection, + ServerAddress* address); virtual ~Server(); status_t SendCall(Call* call, Reply** reply); status_t SendCallAsync(Call* call, Reply** reply, Request** request); - status_t ResendCallAsync(Call* call, Request* req); + status_t ResendCallAsync(Call* call, + Request* request); + inline status_t WaitCall(Request* request, bigtime_t time = kWaitTime); inline status_t CancelCall(Request* request); @@ -72,7 +74,7 @@ public: inline ServerAddress LocalID() const; inline ProgramData* PrivateData(); - inline void SetPrivateData(ProgramData* priv); + inline void SetPrivateData(ProgramData* privateData); private: inline uint32 _GetXID(); @@ -80,7 +82,7 @@ private: status_t _StartListening(); status_t _Listener(); - static status_t _ListenerThreadStart(void* ptr); + static status_t _ListenerThreadStart(void* object); thread_id fThread; bool fThreadCancel; @@ -126,7 +128,7 @@ Server::LocalID() const { ServerAddress addr; memset(&addr, 0, sizeof(addr)); - fConnection->GetLocalID(&addr); + fConnection->GetLocalAddress(&addr); return addr; } @@ -139,10 +141,10 @@ Server::PrivateData() inline void -Server::SetPrivateData(ProgramData* priv) +Server::SetPrivateData(ProgramData* privateData) { delete fPrivateData; - fPrivateData = priv; + fPrivateData = privateData; } @@ -160,13 +162,13 @@ public: ServerManager(); ~ServerManager(); - status_t Acquire(Server** pserv, const ServerAddress& id, - ProgramData* (*createPriv)(Server*)); - void Release(Server* serv); + status_t Acquire(Server** _server, const ServerAddress& address, + ProgramData* (*createPrivateData)(Server*)); + void Release(Server* server); private: - ServerNode* _Find(const ServerAddress& id); + ServerNode* _Find(const ServerAddress& address); void _Delete(ServerNode* node); ServerNode* _Insert(ServerNode* node);