Unix-FileSystem/BufferCache/BufferCache.cpp at master · PrimeMHD/Unix-FileSystem · GitHub

History

230 lines (200 loc) · 6.16 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

#include "../include/BufferCache.h"

#include "../include/Kernel.h"

#include "../include/VirtualProcess.h"

#include "../include/Logcat.h"

void BufferCache::setDiskDriver(DiskDriver *diskDriver)

{

this->diskDriver = diskDriver;

}

int BufferCache::mount()

{

initialize();

return diskDriver->mount();

}

void BufferCache::unmount()

{

Bflush();

diskDriver->unmount();

} //unmount的时候需要把脏缓存刷回

/**

* 缓存控制块的初始化。

void BufferCache::initialize()

{

int i;

Buf *bp;

this->bFreeList.b_forw = this->bFreeList.b_back = &(this->bFreeList);

this->bFreeList.av_forw = this->bFreeList.av_back = &(this->bFreeList);

for (i = 0; i < BUFFER_CACHE_NUM; i++)

{

bp = &(this->m_Buf[i]);

bp->b_blkno = -1;

bp->b_dev = -1;

bp->b_addr = &Buffer[i];

/* 初始化NODEV队列 */

//bp->b_back = &(this->bFreeList);

//bp->b_forw = this->bFreeList.b_forw;

//this->bFreeList.b_forw->b_back = bp;

//this->bFreeList.b_forw = bp;

/* 初始化自由队列 */

bp->b_flags = Buf::B_BUSY;

Brelse(bp); //放入自有缓存队列

}

/**

* 将物理盘块一整块读入diskBlockPool

Buf *BufferCache::Bread(int blkno)

{

Buf *bp;

/* 根据块号申请缓存 */

bp = this->GetBlk(blkno);

/* 如果在设备队列中找到所需缓存，即B_DONE已设置，就不需进行I/O操作 */

if (bp->b_flags & Buf::B_DONE) //DONE是数据一致性的表示

{

return bp; //说明太好了，有现成的缓存块（副本和磁盘一致）

}

/* 没有找到相应缓存，构成I/O读请求块 */

bp->b_flags |= Buf::B_READ;

bp->b_wcount = DISK_BLOCK_SIZE;

diskDriver->readBlk(blkno, bp->b_addr);

bp->b_flags |= Buf::B_DONE;

return bp;

}

/**

* 将一个缓存块中的东西写回磁盘

void BufferCache::Bwrite(Buf *bp)

{

unsigned int flags;

flags = bp->b_flags;

bp->b_flags &= ~(Buf::B_READ | Buf::B_DONE | Buf::B_ERROR | Buf::B_DELWRI);

bp->b_wcount = DISK_BLOCK_SIZE;

//this->m_DeviceManager->GetBlockDevice(Utility::GetMajor(bp->b_dev)).Strategy(bp);

if ((flags & Buf::B_DELWRI) == 0)

{

* 如果不是延迟写，则检查错误；否则不检查。

* 这是因为如果延迟写，则很有可能当前进程不是

* 操作这一缓存块的进程，而在GetError()主要是

* 给当前进程附上错误标志。

Logcat::log("BufferCache", "bwrite出错！");

}

else

{

diskDriver->writeBlk(bp->b_blkno, *bp->b_addr);

bp->b_flags |= Buf::B_DONE;

std::cout << bp->b_blkno << std::endl;

}

return;

}

/**

* 延迟写磁盘块

void BufferCache::Bdwrite(Buf *bp)

{

/* 置上B_DONE允许其它进程使用该磁盘块内容 */

bp->b_flags |= (Buf::B_DELWRI | Buf::B_DONE);

this->Brelse(bp);

return;

}

/**

* 将dev指定设备队列中延迟写的缓存全部输出到磁盘.可能是在卸载磁盘的时候，需要全部刷回

void BufferCache::Bflush()

{

Buf *bp;

for (bp = this->bFreeList.b_forw; bp != &(this->bFreeList); bp = bp->b_forw)

{

/* 找出自由队列中所有延迟写的块 */

if ((bp->b_flags & Buf::B_DELWRI))

{

//bwrite方法会清除B_DELWRI标志的

//this->NotAvail(bp);

this->Bwrite(bp);

//this->Brelse(bp);

//std::cout << bp->b_blkno << std::endl;

}

return;

}

//void writeBlk(int blkno, const DiskBlock &contentToWrite); //将内存的一块区域，写入缓冲区（如果不在缓冲区的话，需要先读）

/**

* 申请一块缓存，用于读写设备dev上的字符块blkno

Buf *BufferCache::GetBlk(int blkno)

{

Buf *bp;

//Devtab *dp;

User &u = VirtualProcess::Instance()->getUser();

* 如果设备队列中已经存在相应缓存，则返回该缓存；

* 否则从自由队列中分配新的缓存用于字符块读写。

/* 表示请求NODEV设备中字符块 */

/* 首先在该设备队列中搜索是否有相应的缓存 */

for (bp = bFreeList.b_forw; bp != &bFreeList; bp = bp->b_forw)

{

/* 不是要找的缓存，则继续 */

if (bp->b_blkno != blkno)

continue;

/* 从自由队列中抽取出来 */

this->NotAvail(bp);

return bp; //可能会有延迟写标志

}

/* 取自由队列第一个空闲块 */

bp = this->bFreeList.av_forw;

this->NotAvail(bp);

/* 如果该字符块是延迟写，将其异步写到磁盘上 */

if (bp->b_flags & Buf::B_DELWRI)

{

this->Bwrite(bp);

}

/* 注意: 这里清除了所有其他位，只设了B_BUSY */

bp->b_flags = Buf::B_BUSY; //若有延迟写bit，也一并消除了

bp->b_blkno = blkno;

memset(bp->b_addr, 0, DISK_BLOCK_SIZE);

if (bp->b_dev != devno)

{

//加入设备缓存队列

bp->b_back = &(this->bFreeList);

bp->b_forw = this->bFreeList.b_forw;

this->bFreeList.b_forw->b_back = bp;

this->bFreeList.b_forw = bp;

bp->b_dev = devno;

}

return bp;

}

/**

* 获取自由缓存队列控制块Buf对象引用

Buf &BufferCache::GetBFreeList()

{

return this->bFreeList;

}

//TODO 这里有bug

void BufferCache::NotAvail(Buf *bp)

{

/* 从自由队列中取出 */

bp->av_back->av_forw = bp->av_forw;

bp->av_forw->av_back = bp->av_back;

/* 设置B_BUSY标志 */

bp->b_flags |= Buf::B_BUSY;

return;

}

/**

* 将一个缓存控制块放到自有缓存队列中，

* 注意以下操作并没有清除B_DELWRI、B_WRITE、B_READ、B_DONE标志

* B_DELWRI表示虽然将该控制块释放到自由队列里面，但是有可能还没有些到磁盘上。

* B_DONE则是指该缓存的内容正确地反映了存储在或应存储在磁盘上的信息

void BufferCache::Brelse(Buf *bp)

{

bp->b_flags &= ~(Buf::B_WANTED | Buf::B_BUSY | Buf::B_ASYNC); //消除这些位的符号（这里其实没用到）

(this->bFreeList.av_back)->av_forw = bp;

bp->av_back = this->bFreeList.av_back;

bp->av_forw = &(this->bFreeList);

this->bFreeList.av_back = bp;

return;

}

Unix-FileSystem/BufferCache/BufferCache.cpp at master · PrimeMHD/Unix-FileSystem · GitHub

Expand file tree

Breadcrumbs

BufferCache.cpp

Latest commit

History

Breadcrumbs

BufferCache.cpp

File metadata and controls