pointer to the buffer containing sector would be returned by the call to getblock the client would then copy bytes to positions - of the bufferand call dirtyblock to warn the buffer pool that the contents of this block have been modified further problem with the second adt is the risk of stale pointers when the buffer pool user is given pointer to some buffer space at time that pointer does indeed refer to the desired data at that time as further requests are made to the buffer poolit is possible that the data in any given buffer will be removed and replaced with new data if the buffer pool user at later time then refers to the data referred to by the pointer given at time it is possible that the data are no longer valid because the buffer contents have been replaced in the meantime thus the pointer into the buffer pool' memory has become "stale to guarantee that pointer is not staleit should not be used if intervening requests to the buffer pool have taken place we can solve this problem by introducing the concept of user (or possibly multiple usersgaining access to bufferand then releasing the buffer when done we will add method acquirebuffer and releasebuffer for this purpose method acquirebuffer takes block id as input and returns pointer to the buffer that will be used to store this block the buffer pool will keep count of the number of requests currently active for this block method releasebuffer will reduce the count of active users for the associated block buffers associated with active blocks will not be eligible for flushing from the buffer pool this will lead to problem if the client neglects to release active blocks when they are no longer needed there would also be problem if there were more total active blocks than buffers in the buffer pool howeverthe buffer pool should always be initialized to include more buffers than will ever be active at one time an additional problem with both adts presented so far comes when the user intends to completely overwrite the contents of blockand does not need to read in the old contents already on disk howeverthe buffer pool cannot in general know whether the user wishes to use the old contents or not this is especially true with the message-passing approach where given message might overwrite only part of the block in this casethe block will be read into memory even when not neededand then its contents will be overwritten this inefficiency can be avoided (at least in the buffer-passing versionby separating the assignment of blocks to buffers from actually reading in data for the block in particularthe following revised buffer-passing adt does not actually read data in the acquirebuffer method users who wish to see the old con