projects / OpenSPARC-T2-SAM / blob
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial commit of OpenSPARC T2 architecture model.
[OpenSPARC-T2-SAM] / sam-t2 / sam / devices / common / disk.cc
// ========== Copyright Header Begin ==========================================
//
// OpenSPARC T2 Processor File: disk.cc
// Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
// DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
//
// The above named program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public
// License version 2 as published by the Free Software Foundation.
//
// The above named program is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public
// License along with this work; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
// ========== Copyright Header End ============================================
#include "disk.h"
SCSIDisk * parser_disk;
std::list<Disk *> * diskList;
std::list<Disk *>::iterator diskListIter;
bool Disk::UI_registered = false;
// parser for disk configuration
extern int scsi_parse_config(const char * fname, FILE *fp, int target);
int gdisk_ui_cmd(void*, int argc, char * argv[]){
if(argc == 1){
for(diskListIter = diskList->begin(); diskListIter != diskList->end(); diskListIter++)
fprintf(stderr," %s\n",(*diskListIter)->get_name());
return 0;
}else if(argc == 2){
if(!strcmp("help",argv[1])){
diskListIter = diskList->begin();
(*diskListIter)->display_help();
return 0;
}else{
fprintf(stderr,"gdisk: unknown command %s\n",argv[1]);
fprintf(stderr,"gdisk: Try \"gdisk help\"\n");
return 0;
}
}
for(diskListIter = diskList->begin(); diskListIter != diskList->end(); diskListIter++)
if(!strcmp((*diskListIter)->get_name(),argv[1])){
(*diskListIter)->handle_ui(argc,argv);
return 0;
}
if (!strcmp(argv[1], "all")) {
for(diskListIter = diskList->begin(); diskListIter != diskList->end(); diskListIter++)
(*diskListIter)->handle_ui(argc,argv);
return 0;
}
fprintf(stderr,"gdisk: No disk %s configured\n",argv[1]);
return 0;
}
Partition::Partition(){
debug_level = 0;
debug_file = stderr;
part_filename = 0;
part_name = 0;
overlay_filename = 0;
ckpt_filename = 0;
rw = false;
has_vtoc = false;
size = 0;
nblks = 0;
start_lblk = 0;
end_lblk = 0;
index = -1;
primary_fd = -1;
overlay_fd = -1;
ckpt_fd = -1;
bitmap_size = 0;
overlay_bitmap = 0;
ckpt_bitmap = 0;
lblk_reads = 0;
lblk_writes = 0;
lblk_reads_primary = 0;
lblk_writes_primary = 0;
lblk_reads_overlay = 0;
lblk_writes_overlay = 0;
lblk_reads_ckpt = 0;
}
Disk::Disk(const char * name){
disk_name = name ? strdup(name) : strdup("Disk");
for(int i = 0; i < MAX_PARTITIONS; i++)
partitions[i] = 0;
target_id = -1;
is_s2 = false;
debug_level = 0;
debug_file = stderr;
strcpy(debug_file_name,"stderr");
num_partitions = 0;
vtoc_partition = -1;
fake_vtoc = false;
num_cylinder = 0;
num_blks = 0;
user_geometry = false;
read_delay = READ_DELAY_DEFAULT;
write_delay = WRITE_DELAY_DEFAULT;
bzero((void*)&disk_label, sizeof(disk_label));
struct stat statbuf;
if(stat(overlaydir, &statbuf) == 0){
if (!S_ISDIR(statbuf.st_mode) ) {
fprintf(debug_file,"%s: overlay dir %s does not exist\n",disk_name,overlaydir);
exit(1);
}
}
// default values, in case vtoc needs to be faked
sectors_per_track = 32;
tracks_per_cylinder = 16;
bytes_per_sector = BYTES_PER_SECTOR; // constant
if(!UI_registered){
UI_registered = true;
UI_register_cmd_2 ("gdisk", "", gdisk_ui_cmd, NULL);
diskList = new std::list<Disk *>;
}
}
SCSIDisk::SCSIDisk():Disk(0){
vendorid = sid.vendor;
productid = sid.product;
revisionid = sid.revision;
serialno = sid.serialnum;
prodserialno = usn.productSerialNumber;
brdserialno = usn.boardSerialNumber;
portwwn = fdi.id0;
nodewwn = fdi.id1;
sizeof_vendorid = sizeof(sid.vendor);
sizeof_productid = sizeof(sid.product);
sizeof_revisionid = sizeof(sid.revision);
sizeof_serialno = sizeof(sid.serialnum);
sizeof_prodserialno = sizeof(usn.productSerialNumber);
sizeof_brdserialno= sizeof(usn.boardSerialNumber);
sizeof_portwwn = sizeof(fdi.id0);
sizeof_nodewwn = sizeof(fdi.id1);
Supported_VPD_size = 0x8;
sv.pageLength = 0x4; // support the first 4 VPD only
}
SCSIDisk::~SCSIDisk(){}
bool SCSIDisk::parse_config(const char * filename, FILE * fp, int target){
assert(fp);
parser_disk = this;
num_partitions = 0;
int ret = scsi_parse_config(filename, fp, target);
if(ret){
fprintf(stderr,"Error parsing disk config file %s\n",filename);
exit(1);
}
if (num_partitions == 0)
return true;
add_partition_fini();
if(!fake_vtoc && user_geometry){
fprintf(stderr,"%s Error:Can't specify VTOC geometry for real disk labels\n",get_name());
assert(0);
}
if(!create_overlays())
exit(1);
for(diskListIter = diskList->begin(); diskListIter != diskList->end(); diskListIter++){
if(!strcmp(get_name(),(*diskListIter)->get_name())){
fprintf(stderr,"Error: Disk %s already configured,\n Provide unique names to disks.\n",get_name());
exit(1);
}
}
diskList->push_front(this);
if(!fake_vtoc) {
disk_read_lblk(0,(uint8_t*)&disk_label,1);
#if defined(ARCH_X64)
label_endian_convert(&disk_label);
#endif
}
return true;
}
bool Disk::add_partition_fini(){
// assumes _SUNOS_VTOC_8
// all paritions have been read. Now create the vtoc if needed, adjust the
// start, end lblks etc.
char buf[BYTES_PER_SECTOR];
if(vtoc_partition == -1)
// need to fake the vtoc
fake_vtoc = true;
if(!fake_vtoc){
// Do not need to fake a vtoc
// 1. Read the vtoc and initialize partition start/end/number blocks according to
// the vtoc
lseek(partitions[vtoc_partition]->primary_fd,0,SEEK_SET);
if(read(partitions[vtoc_partition]->primary_fd,(void*)(buf),BYTES_PER_SECTOR) != BYTES_PER_SECTOR){
fprintf(debug_file,"%s: Cannot read sector 0 on %s\n",disk_name,partitions[vtoc_partition]->part_filename);
perror("");
exit(1);
}
struct vtoc8_dk_label * dkl = (vtoc8_dk_label*) buf;
if(is_s2){
// 1. See if this is s2 partition
assert(vtoc_partition == 2);
partitions[2]->nblks = dkl->dkl_map[2].dkl_nblk;
partitions[2]->start_lblk = dkl->dkl_map[2].dkl_cylno * dkl->dkl_nsect * dkl->dkl_nhead;
partitions[2]->end_lblk = partitions[2]->start_lblk + partitions[2]->nblks - 1;
num_blks = partitions[2]->nblks;
if(partitions[2]->nblks * BYTES_PER_SECTOR != partitions[2]->size){
fprintf(debug_file,"%s Warning: %s size (%lld) not same as size in vtoc (%lld)\n",\
disk_name,partitions[2]->part_filename,partitions[2]->size,partitions[2]->nblks * BYTES_PER_SECTOR);
}
}else{
// initialize other partitions from the vtoc
partitions[vtoc_partition]->nblks = dkl->dkl_map[vtoc_partition].dkl_nblk;
partitions[vtoc_partition]->start_lblk = dkl->dkl_map[vtoc_partition].dkl_cylno * dkl->dkl_nsect * dkl->dkl_nhead;
partitions[vtoc_partition]->end_lblk = partitions[vtoc_partition]->start_lblk + partitions[vtoc_partition]->nblks - 1;
for(int i = 0; i < MAX_PARTITIONS; i++){
if(i == vtoc_partition)
continue;
if(partitions[i] == 0)
continue;
partitions[i]->nblks = dkl->dkl_map[i].dkl_nblk;
if(partitions[i]->nblks == 0){
// nblk == 0 means undefined partition.
// The user has added a partition which
// is not present in the real
// vtoc in the disk. Treat as fatal error.
fprintf(debug_file,"%s: configuring parition %d(%s) not present in disk vtoc.\n",\
disk_name,i,partitions[i]->part_filename);
assert(partitions[i]->nblks);
}
partitions[i]->start_lblk = dkl->dkl_map[i].dkl_cylno * dkl->dkl_nsect * dkl->dkl_nhead;
partitions[i]->end_lblk = partitions[i]->start_lblk + partitions[i]->nblks - 1;
num_blks += partitions[i]->nblks;
if(partitions[i]->nblks * BYTES_PER_SECTOR != partitions[i]->size)
fprintf(debug_file,"%s: Warning: %s size (%lld) not same as size in vtoc (%lld)\n",\
disk_name,partitions[i]->part_filename,partitions[i]->size,partitions[i]->nblks * BYTES_PER_SECTOR);
}
for(int i = 0; i < VTOC8_NDKMAP; i++)
if(i != 2 && dkl->dkl_map[i].dkl_nblk != 0){
if(partitions[i] == 0){
// some partitions present in VTOV are not bein added.
// Reads/writes will be ignored.
fprintf(debug_file,"%s: Warning - partition %d present in VTOC not configured\n",disk_name,i);
fprintf(debug_file,"%s: Warning - some reads/writes MAY not succeed \n",disk_name);
}
}
}
sectors_per_track = dkl->dkl_nsect; // default 32
tracks_per_cylinder = dkl->dkl_nhead; // default 16
num_cylinder = ceil(1.0 * num_blks/sectors_per_track/tracks_per_cylinder);// total number of cyinders in disk
return true;
}
// create the fake vtoc.
// start init'ing the disk label
strcpy(disk_label.dkl_ascii_label,"SUN");
disk_label.dkl_rpm = DKLABEL_RPM;
disk_label.dkl_intrlv = DKLABEL_INTRLV;
disk_label.dkl_acyl = DKLABEL_ACYL;
disk_label.dkl_magic = DKLABEL_MAGIC;
disk_label.dkl_write_reinstruct = 0;
disk_label.dkl_read_reinstruct = 0;
disk_label.dkl_nsect = sectors_per_track;
disk_label.dkl_nhead = tracks_per_cylinder;
disk_label.dkl_vtoc.v_nparts = MAX_PARTITIONS;
disk_label.dkl_vtoc.v_version = 0x1;
disk_label.dkl_vtoc.v_sanity = VTOC_SANITY;
strcpy(disk_label.dkl_vtoc.v_volume,"SAM_VOL");
// start the lowest specified partition from cylinder 0 or 1.
if(is_s2)
num_cylinder = 0;
else
num_cylinder = 1;
for( int i = 0; i < MAX_PARTITIONS; i++){
if( (partitions[i] == 0) )
continue;
if(!is_s2){
// we are creating a fake vtoc. check to see if the partition
// itself does not contain a vtoc. If it does, the access will fail
// as sector 0 will be duplicated. We bail out on such cases. The
// user needs to use the vtoc on partition here. This does not apply
// to s2 since the OS knows there is a label at sector 0, whether
// faked or real. Treat as fatal.
struct vtoc8_dk_label * dkl = (vtoc8_dk_label*) buf;
lseek(partitions[i]->primary_fd,0,SEEK_SET);
read(partitions[i]->primary_fd,buf,BYTES_PER_SECTOR);
if(dkl->dkl_magic == DKLABEL_MAGIC){
fprintf(stderr,"%s.%s: Disk Label found on sector 0 of %s\n",\
disk_name,partitions[i]->part_name,partitions[i]->part_filename);
fprintf(stderr," : Use the label on image or clip sector 0\n.");
assert(0);
}
}
if(!is_s2)
disk_label.dkl_vtoc.v_part[i].p_tag = 0x04; // User
else
disk_label.dkl_vtoc.v_part[2].p_tag = 0x02; // Root
disk_label.dkl_vtoc.v_part[i].p_flag = 0x00; // Mountable, rw
disk_label.dkl_map[i].dkl_cylno = num_cylinder;
disk_label.dkl_map[i].dkl_nblk = ceil(1.0 * partitions[i]->size / bytes_per_sector);
int64_t cylinders_in_partition = ceil ( 1.0 * disk_label.dkl_map[i].dkl_nblk / sectors_per_track / tracks_per_cylinder );
if( num_cylinder + cylinders_in_partition > 0x7fffffffLL){
fprintf(debug_file,"%s: number of cylinders exceed 0x7fffffff. Modify VTOC\n",disk_name);
exit(1);
}else
num_cylinder += cylinders_in_partition;
num_blks += disk_label.dkl_map[i].dkl_nblk;
}
disk_label.dkl_pcyl = num_cylinder;
disk_label.dkl_ncyl = num_cylinder;
set_dkl_cksum();
// fill in the start/end/num blocks in partitions
for( int i = 0; i < MAX_PARTITIONS; i++){
if( partitions[i] == 0 )
continue;
partitions[i]->nblks = disk_label.dkl_map[i].dkl_nblk;
partitions[i]->start_lblk = disk_label.dkl_map[i].dkl_cylno * disk_label.dkl_nsect * disk_label.dkl_nhead;
partitions[i]->end_lblk = partitions[i]->start_lblk + partitions[i]->nblks - 1;
}
// SCSI CAPACITY command reads the numberof nblocks in the disk. It is a 32 bit
// unsigned number. That gives a limit on size of disk as 2^32 * 512 = 2^41
// bytes or 2 TB. Put a check here for this limit. Note that this would not
// work in case of real VTOC, where partitions can overlap. SAM does not
// create disks from partitions that overlap, hence this check works.
if(num_blks > 0xffffffffULL ){
fprintf(debug_file,"%s: Fatal - Total disk size exceeds 2 TB!! LBLKS = %lld\n",disk_name,num_blks);
assert(0);
}
return true;
}
// return true on success, else false
bool Disk::add_partition(int partition, const char * filename, bool rw, bool has_vtoc){
assert(partition <= 7);
if(partition == 2){
// only one partition is allowed. It may or may not have a vtoc
if(num_partitions != 0){
fprintf(stderr,"Cannot have more than 1 partitions with s2\n");
assert(num_partitions == 0);
}
is_s2 = true;
}else{
if(is_s2){
// this disk is being configured with an s2 along with other
// partition. Not allowed
fprintf(stderr,"Can't have another partition with s2\n");
assert(!is_s2);
}
}
if(has_vtoc){
assert(vtoc_partition == -1);
vtoc_partition = partition;
}
char buf[128];
struct stat statbuf;
int fd = -1;
int oflag = O_RDONLY|O_LARGEFILE; // XXX choose based upon 'rw' mode
if( (fd = open(filename, oflag)) == -1){
fprintf(debug_file,"%s: open() file %s errno: %d , %s \n", disk_name, filename, errno, strerror(errno));
return false;
}
if(stat(filename, &statbuf) == -1){
fprintf(debug_file,"%s: Could not stat() file %s \n",disk_name, filename);
return false;
}
assert(partitions[partition] == 0);
Partition * P = partitions[partition] = new Partition();
P->index = partition;
P->has_vtoc = has_vtoc;
P->part_filename = strdup(filename);
P->primary_fd = fd;
sprintf(buf,"s%d",partition);
P->part_name = strdup(buf);
P->rw = rw;
P->is_device_file = statbuf.st_rdev;
if(!P->is_device_file)
P->size = statbuf.st_size;
else{
P->size = lseek(fd,0,SEEK_END);
lseek(fd,0,SEEK_SET);
}
if(P->size % BYTES_PER_SECTOR){
fprintf(debug_file,"partition %d(%s) size not multiple of %d bytes\n",partition,filename,BYTES_PER_SECTOR);
assert(0);
}
num_partitions++;
return true;
}
// return number of bytes written, -1 on error
uint32_t Disk::disk_write_lblk( uint64_t lblkno, uint8_t *buf, uint32_t nblks ){
uint32_t ret = 0;
uint32_t blocks_to_write = nblks;
if(lblkno == 0 && fake_vtoc){
bcopy(buf,&disk_label,BYTES_PER_SECTOR);
#if defined(ARCH_X64)
label_endian_convert(&disk_label);
#endif
buf += BYTES_PER_SECTOR;
lblkno++;
blocks_to_write--;
ret++;
}
for(int i = 0; i < MAX_PARTITIONS && blocks_to_write; i++){
if(partitions[i] && partitions[i]->lblk_inrange(lblkno)){
// handle case of overlapping partitions. The lowest numbered
// partition having the block is read/written to
uint32_t retp = partitions[i]->Write(lblkno, buf, blocks_to_write);
blocks_to_write -= retp;
lblkno += retp;
ret += retp;
}
}
if(ret != nblks)
fprintf(debug_file,"%s:Warning. Write request at lblk %lld of size %ld wrote %ld lblks\n",disk_name,lblkno,nblks,ret);
return ret;
}
// return number of bytes written
uint32_t Disk::disk_read_lblk( uint64_t lblkno, uint8_t *buf, uint32_t nblks ){
bzero(buf,nblks * BYTES_PER_SECTOR);
uint32_t ret = 0;
uint32_t blocks_to_read = nblks;
if(lblkno == 0 && fake_vtoc){
#if defined(ARCH_X64)
struct vtoc8_dk_label tmp;
bcopy(&disk_label,&tmp,sizeof(disk_label));
label_endian_convert(&tmp);
bcopy(&tmp,buf,BYTES_PER_SECTOR);
#else
bcopy(&disk_label,buf,BYTES_PER_SECTOR);
#endif
buf += BYTES_PER_SECTOR;
lblkno++;
blocks_to_read--;
ret++;
}
for(int i = 0; i < MAX_PARTITIONS && blocks_to_read; i++){
if(partitions[i] && partitions[i]->lblk_inrange(lblkno)){
// handle case of overlapping partitions. The lowest numbered
// partition having the block is read/written to
uint32_t retp = partitions[i]->Read(lblkno, buf, blocks_to_read);
blocks_to_read -= retp;
lblkno += retp;
ret += retp;
}
}
if(ret != nblks)
fprintf(debug_file,"%s:Warning. Read request at lblk %lld of size %ld read %ld lblks\n",disk_name,lblkno,nblks,ret);
return ret;
}
bool Disk::dump(const char * dir){
bool ret = true;
for(int i = 0; i < MAX_PARTITIONS; i++){
if(partitions[i] ){
ret &= partitions[i]->dump(dir,disk_name);
}
}
ret &= dump_misc(dir);
return ret;
}
bool Disk::restore(const char * dir){
bool ret = true;
for(int i = 0; i < MAX_PARTITIONS; i++){
if(partitions[i] ){
ret &= partitions[i]->restore(dir,disk_name);
}
}
ret &= restore_misc(dir);
return ret;
}
bool Partition::dump(const char * dir, const char * disk_name){
bool ret = true;
bitset * b = new bitset (bitmap_size);
b->Or(overlay_bitmap);
if(ckpt_bitmap) b->Or(ckpt_bitmap);
char buf[1024];
sprintf(buf, "%s/%s.%s.dmp",dir,disk_name,part_name);
FILE * fp = fopen(buf,"w");
ret &= b->dump(fp);
fclose(fp);
sprintf(buf, "%s/%s.%s.shadow",dir,disk_name,part_name);
int to_fd = open(buf,O_WRONLY|O_CREAT|O_LARGEFILE,0777);
assert(to_fd != -1);
lseek(to_fd,nblks*BYTES_PER_SECTOR - 1,SEEK_SET);
assert(write(to_fd,"",1) == 1);
int src_fd = -1;
const char * src_file= 0;
for(uint64_t i = 0; i < bitmap_size; i++){
char tmpbuf[DISK_PAGE_SIZE];
if(overlay_bitmap->get(i)){
src_fd = overlay_fd;
src_file = overlay_filename;
}else if(ckpt_bitmap && ckpt_bitmap->get(i)){
src_fd = ckpt_fd;
src_file = ckpt_filename;
}else
continue;
lseek(src_fd,i * DISK_PAGE_SIZE, SEEK_SET);
read(src_fd,tmpbuf,DISK_PAGE_SIZE);
lseek(to_fd,i * DISK_PAGE_SIZE, SEEK_SET);
if(write(to_fd,tmpbuf,DISK_PAGE_SIZE) != DISK_PAGE_SIZE){
fprintf(debug_file,"%s:Error writing checkpoint file %s offset %llx\n",part_name,buf,i*DISK_PAGE_SIZE);
perror("");
return false;
}
}
close(to_fd);
return ret;
}
bool Partition::restore(const char * dir, const char * disk_name){
bool ret = true;
char buf[1024];
sprintf(buf, "%s/%s.%s.dmp",dir,disk_name,part_name);
FILE * fp = fopen(buf,"r");
assert(fp);
ckpt_bitmap = new bitset(bitmap_size,part_name);
ckpt_bitmap->restore(fp);
fclose(fp);
sprintf(buf,"%s/%s.%s.shadow",dir,disk_name,part_name);
ckpt_filename = strdup(buf);
if( (ckpt_fd = open(ckpt_filename, O_RDONLY|O_LARGEFILE)) == -1){
fprintf(debug_file,"%s: open() file %s errno: %d , %s \n", disk_name, ckpt_filename, errno, strerror(errno));
ret &= false;
}
return ret;
}
uint32_t Partition::Read(uint64_t lblkno, uint8_t *buf, uint32_t numblks){
uint64_t relative_lblk = lblkno - start_lblk; // lblk from start of backup file
uint64_t bitmap_pos;
int src_fd = -1;
const char * src_file = 0;
uint32_t blocks_read = 0;
char tmpbuf[DISK_PAGE_SIZE];
bzero(tmpbuf,DISK_PAGE_SIZE);
while(numblks != blocks_read){
uint32_t blks_in_cur_page = (BLOCKS_PER_PAGE - relative_lblk % BLOCKS_PER_PAGE)\
< (numblks - blocks_read) ? (BLOCKS_PER_PAGE - relative_lblk % BLOCKS_PER_PAGE):numblks - blocks_read;
bitmap_pos = relative_lblk/BLOCKS_PER_PAGE; // 1 bit for every BLOCKS_PER_PAGE lblks
if(overlay_bitmap->get(bitmap_pos)){
src_fd = overlay_fd; // page has been modified earlier
src_file = overlay_filename;
lblk_reads_overlay += blks_in_cur_page;
}else if(ckpt_bitmap && ckpt_bitmap->get(bitmap_pos)){
src_fd = ckpt_fd; // page has been modified and is present in the chpt
src_file = ckpt_filename;
lblk_reads_ckpt += blks_in_cur_page;
}else{
src_fd = primary_fd; // page has not been written to yet. read from
// actual partition
src_file = part_filename;
lblk_reads_primary += blks_in_cur_page;
}
if(lseek(src_fd,bitmap_pos * DISK_PAGE_SIZE ,SEEK_SET) != bitmap_pos * DISK_PAGE_SIZE){
// the partition file does not have requested lblk. This may happen if
// vtoc specified a different parition size than the actual file size,
// or there may be partially filled lblk. In this case we can't
// write(barring certain cases). We print an error message and
// continue. The user needs to decide if this is fatal or not.
fprintf(debug_file,"%s: Request to seek at lblk %llx, backup file %s map<%llx,%llx> failed.\n",part_name,relative_lblk+start_lblk,src_file,start_lblk,end_lblk);
perror("");
return blocks_read;
}
if(read(src_fd, tmpbuf, DISK_PAGE_SIZE) != DISK_PAGE_SIZE){
// src_fd is smaller than we thought. Flag an error, leave it to
// user to decide if its fatal. XXX cannot happen if DISK_PAGE_SIZE
// == BYTES_PER_SECTOR
fprintf(debug_file,"%s: Request to read at lblk %llx, backup file %s map<%llx,%llx> failed.\n Data could be partial content\n",part_name,relative_lblk+start_lblk,src_file,start_lblk,end_lblk);
perror("");
}
bcopy(tmpbuf + (relative_lblk % BLOCKS_PER_PAGE) *BYTES_PER_SECTOR,\
buf, blks_in_cur_page*BYTES_PER_SECTOR);
blocks_read += blks_in_cur_page;
buf += blks_in_cur_page * BYTES_PER_SECTOR;
relative_lblk += blks_in_cur_page;
}
lblk_reads += blocks_read;
return blocks_read;
}
// return the number of lblks written
uint32_t Partition::Write(uint64_t lblkno, uint8_t *buf, uint32_t numblks){
const uint32_t blocks_to_write = numblks;
uint64_t relative_lblk = lblkno - start_lblk; // lblk from start of backup file
uint64_t bitmap_pos;
int src_fd = -1;
int to_fd = rw ? primary_fd:overlay_fd; // file to which data would be written
assert(to_fd != -1);
char tmpbuf[DISK_PAGE_SIZE]; // read/write DISK_PAGE_SIZE at a time
const char * src_file = 0;
const char * to_file = rw?part_filename: overlay_filename;
bzero(tmpbuf,DISK_PAGE_SIZE);
uint32_t blocks_written = 0;
while(numblks != blocks_written){
uint32_t blks_in_cur_page = (BLOCKS_PER_PAGE - relative_lblk % BLOCKS_PER_PAGE)\
< (numblks - blocks_written) ? (BLOCKS_PER_PAGE - relative_lblk % BLOCKS_PER_PAGE):numblks - blocks_written;
bitmap_pos = relative_lblk/BLOCKS_PER_PAGE; // 1 bit for every BLOCKS_PER_PAGE lblks
if(overlay_bitmap->get(bitmap_pos)){
src_fd = overlay_fd; // page has been modified earlier
src_file = overlay_filename;
}else if(ckpt_bitmap && ckpt_bitmap->get(bitmap_pos)){
src_fd = ckpt_fd; // page has been modified and is present in the chpt
src_file = ckpt_filename;
}else{
src_fd = primary_fd; // page has not been written to yet. Next
// writes will have src_fd = overlay_fd if this
// is ro option
src_file = part_filename;
if(!rw) overlay_bitmap->set(bitmap_pos);
}
if(lseek(src_fd,bitmap_pos * DISK_PAGE_SIZE ,SEEK_SET) != bitmap_pos * DISK_PAGE_SIZE){
// the parition file does not have requested lblk. This may happen if
// vtoc specified a different parition size than the actual file size,
// or there may be partially filled lblk. In this case we can't
// write(barring certain cases). We print an error message and
// continue. The user needs to decide if this is fatal or not.
fprintf(debug_file,"%s: Request to seek at lblk %llx, file %s map<%llx,%llx> failed\n",part_name,relative_lblk+start_lblk,src_file,start_lblk,end_lblk);
perror("");
return blocks_written;
}
if(read(src_fd, tmpbuf, DISK_PAGE_SIZE) != DISK_PAGE_SIZE){
// src_fd is smaller than we thought. Flag an error, leave it to
// user to decide if its fatal
fprintf(debug_file,"%s: Request to read at lblk %llx, file %s map<%llx,%llx> failed.\n Data write could be partial.\n",part_name,relative_lblk+start_lblk,src_file,start_lblk,end_lblk);
perror("");
}
bcopy(buf,tmpbuf + (relative_lblk % BLOCKS_PER_PAGE)*BYTES_PER_SECTOR,\
blks_in_cur_page*BYTES_PER_SECTOR);
if(lseek(to_fd,bitmap_pos * DISK_PAGE_SIZE ,SEEK_SET) != bitmap_pos * DISK_PAGE_SIZE ){
// should not happen, since this is atleast the vtoc specified size,
// or the real file(rw=true), in which case the lseek would fail above
fprintf(debug_file,"%s: Request to seek at lblk %llx, file %s map<%llx,%llx>. Failed\n",part_name,relative_lblk+start_lblk,to_file,start_lblk,end_lblk);
perror("");
return blocks_written;
}
if(write(to_fd, tmpbuf, DISK_PAGE_SIZE) != DISK_PAGE_SIZE){
// should not happen
fprintf(debug_file,"%s: Request to write at lblk %llx, file %s map<%llx,%llx>. Failed\n",part_name,relative_lblk+start_lblk,to_file,start_lblk,end_lblk);
perror("");
}
buf += blks_in_cur_page * BYTES_PER_SECTOR;
blocks_written += blks_in_cur_page;
relative_lblk += blks_in_cur_page;
if(rw)
lblk_writes_primary += blks_in_cur_page;
else
lblk_writes_overlay += blks_in_cur_page;
}
lblk_writes += blocks_written;
return blocks_written;
}
Full OpenSPARC architecture tarball including simulator, hypervisor, and OBP.