RioObject Class Reference

#include <ObjMapMgr.h>

Public Member Functions
	~RioObject ()
int	Close ()
int	GetSize (RioObjectSize *Size)
int	GetType (short *Type)
int	GetnBlocks (RioBlock *nBlocks)
int	GetBlockMap (RioBlock first, RioBlock nBlocks, RioDiskBlock *blocks)
int	SetSize (RioObjectSize Size, char *md5sum, unsigned long long int ExcludeStorages)
int	MarkDelete ()
int	MapBlock (RioBlock Block, int RepBits, int *numreps, RioDiskBlock *reps)
int	GetObjectName (char *ObjectName)
	Funcao GetObjectName: retorna o nome do arquivo associado ao objeto RioObject.
int	GetVideoRate (unsigned int *VideoRate)
	GetVideoRate retorna a taxa de transmissao (em Kbps) do video.
int	SetVideoRate (unsigned int VideoRate)
	SetVideoRate altera a taxa de transmissao (em Kbps) do video.
int	ReallocBlocks (RioBlock Block, unsigned long long int ExcludeStorages)
	Nova funcao usada para realocar os blocos associados ao ultimo bloco do arquivo associado ao objeto.
Private Member Functions
	RioObject (ObjMapMgr *mgr)
	RioObject (const RioObject &x)
RioObject &	operator= (const RioObject &x)
int	SaveObject ()
void	PrintHdr ()
int	Extend (RioBlock nBlocks, unsigned long long int ExcludeStorages)
int	Truncate (RioBlock nBlocks)
Private Attributes
ObjMapMgr *	o_mgr
char *	o_Name
int	o_FileHandle
bool	o_DeleteOnClose
bool	o_MapChanged
bool	o_MapValid
RioBlock	o_nMapBlocks
RioDiskBlock *	o_Map
bool	o_Locked
bool	o_HdrValid
ObjectHeader	o_Hdr
Friends
class	ObjMapMgr

---

Detailed Description

Definition at line 71 of file ObjMapMgr.h.

---

Constructor & Destructor Documentation

RioObject::RioObject

(

ObjMapMgr *

mgr

)

[private]

Definition at line 373 of file ObjMapMgr.cpp.

{
    // don't need to hold a mutex since no one can see this RioObject yet
    o_mgr           = mgr;
    o_Name          = NULL;
    o_FileHandle    = -1;
    o_DeleteOnClose = false;
    o_MapChanged    = false;
    o_MapValid      = false;
    o_nMapBlocks    = 0;
    o_Map           = NULL;
    o_HdrValid      = false;
    o_Locked        = 1;        // starts out locked
    memset( (char *)&o_Hdr, 0, sizeof( o_Hdr ) );
}

RioObject::RioObject

(

const RioObject &

x

)

[private]

RioObject::~RioObject

(

)

Definition at line 393 of file ObjMapMgr.cpp.

{
    int rc;
    pthread_mutex_lock( &o_mgr->m_mutexfast );
    if( o_FileHandle != -1 )
    {
        close(o_FileHandle);
    }
    delete [] o_Map;
    o_mgr->m_used--;
    pthread_mutex_unlock( &o_mgr->m_mutexfast );

    // delete object if needed
    if( o_DeleteOnClose && ( o_Hdr.Size == 0 ) )
    {
        rc = unlink( o_Name );
        if( rc )
        {
            (*o_mgr->m_log) << "~RioObject unlink for " << o_Name << ": "
                            << strerror(errno) << endl;
        }
    }

    delete [] o_Name;
}

---

Member Function Documentation

int RioObject::Close

(

void

)

Definition at line 422 of file ObjMapMgr.cpp.

{
    time_t t;

    // If file was opened for write update time stamp for file last write
    //    if( o_Access & RIO_WRITE_ACCESS )
    // A variavel o_Access nao e setada em lugar nenhum
//    if( RIO_WRITE_ACCESS )
//    {
        pthread_mutex_lock( &o_mgr->m_mutexmeta );
        time( &t );
        if( t == ( time_t ) - 1 )
        {
            (*o_mgr->m_log) << "RioObject.Close: time failed "
                            << strerror(errno) << endl;
        }
        else
        {
            o_Hdr.LastWrite = t;
        }

        // ### need to write header out to update time...
        if( close( o_FileHandle ) )
        {
            pthread_mutex_unlock( &o_mgr->m_mutexmeta );
            (*o_mgr->m_log) << "ObjMapMgr.Close: close failed "
                            << strerror(errno) << endl;
            return ERROR_OBJECTMANAGER + ERROR_UNEXPECTED;
        }
        pthread_mutex_unlock( &o_mgr->m_mutexmeta );
//    }
    return S_OK;
}

int RioObject::Extend	(	RioBlock	nBlocks,
		unsigned long long int	ExcludeStorages
	)			[private]

Definition at line 740 of file ObjMapMgr.cpp.

{
    RioDiskBlock *newmap, *newp;
    RioBlock n;
    int rc = 0;

    pthread_mutex_lock( &o_mgr->m_mutexfast );

    // first adjust map size to hold additional blocks
    if( o_nMapBlocks >= nBlocks ) goto diskalloc;

    newmap = new RioDiskBlock[ nBlocks * o_Hdr.nRep ];
    if( newmap == 0 )
    {
        pthread_mutex_unlock( &o_mgr->m_mutexfast );
        return ERROR_MEMORY;
    }

    memset(newmap, 0, nBlocks * o_Hdr.nRep * sizeof( RioDiskBlock ));
    memcpy(newmap, o_Map, o_Hdr.nBlocks * o_Hdr.nRep * sizeof( RioDiskBlock ));
    delete [] o_Map;
    o_Map = newmap;
    o_nMapBlocks = nBlocks;

diskalloc:

    for( n = o_Hdr.nBlocks; n < nBlocks; n++ )
    {
        newp = o_Map + ( n * o_Hdr.nRep );
        rc = o_mgr->m_DiskMgr->AllocMult( o_Hdr.nRep, newp, ExcludeStorages );
        if( rc )
            goto quit;
        o_Hdr.nBlocks = n + 1;
    }

    for( n = 0; n < o_Hdr.nBlocks; n++ )
    {
        newp = o_Map + (n * o_Hdr.nRep);
        if( newp->disk == 0 )
        {
            RioErr << "ObjMapMgr:Extend block " << n << " null" << endl;
            abort();
        }
    }

quit:

    o_MapChanged = 1;
    pthread_mutex_unlock( &o_mgr->m_mutexfast );

    SaveObject();   // update obj hdr & map
    // confirm disk allocations made (even if didn't finish)
    o_mgr->m_DiskMgr->Confirm();

    return rc;
}

int RioObject::GetBlockMap	(	RioBlock	first,
		RioBlock	nBlocks,
		RioDiskBlock *	blocks
	)

Definition at line 490 of file ObjMapMgr.cpp.

{
    pthread_mutex_lock( &o_mgr->m_mutexfast );
    if( o_Locked )
    {
        pthread_mutex_unlock( &o_mgr->m_mutexfast );
        return ERROR_OBJECTMANAGER + ERROR_OBJECT_OPEN_FAILED;
    }

    if( ( first + nBlocks ) > o_Hdr.nBlocks )
    {
        pthread_mutex_unlock( &o_mgr->m_mutexfast );
        return ERROR_OBJECTMANAGER + ERROR_INVALID_LOGICAL_BLOCK;
    }

    memcpy( blocks, o_Map + first, nBlocks * sizeof( RioDiskBlock ));

    pthread_mutex_unlock( &o_mgr->m_mutexfast );
    return S_OK;
}

int RioObject::GetnBlocks

(

RioBlock *

nBlocks

)

Definition at line 480 of file ObjMapMgr.cpp.

{
    *nBlocks = o_Hdr.nBlocks;
    return S_OK;
}

int RioObject::GetObjectName

(

char *

ObjectName

)

Funcao GetObjectName: retorna o nome do arquivo associado ao objeto RioObject.

O nome retornado inclui o caminho relativo do arquivo no sistema de arquivos do sistema operacional em que o Servidor RIO esta executando, em relacao ao diretorio do servidor.(esta funcao e usada pela implementacao da cache).

Parameters:

ObjectName

Ponteiro para uma string que ira armazenar o nome do arquivo com o seu caminho. A funcao supoe que existe espaco suficiente na string para copiar o nome no endereco apontado por ObjectName (contando o terminador).

Returns:

S_OK (a funcao nao gera erros).

Definition at line 849 of file ObjMapMgr.cpp.

{
    // Copia o nome do arquivo, incluindo o seu caminho, dado pelo endere�o
    // apontado pelo campo o_Name, para o endere�o apontado por ObjectName.
    strcpy( ObjectName, o_Name );
    return S_OK;
}

int RioObject::GetSize

(

RioObjectSize *

Size

)

Definition at line 468 of file ObjMapMgr.cpp.

{
    *Size = o_Hdr.Size;
    return S_OK;
}

int RioObject::GetType

(

short *

Type

)

Definition at line 474 of file ObjMapMgr.cpp.

{
   *Type = o_Hdr.Type;
   return S_OK;
}

int RioObject::GetVideoRate

(

unsigned int *

VideoRate

)

GetVideoRate retorna a taxa de transmissao (em Kbps) do video.

Parameters:

VideoRate

ponteiro para o inteiro nao sinalizado que armazenara a taxa de transmissao do video.

Returns:

S_OK.

Definition at line 864 of file ObjMapMgr.cpp.

{
    // Obtem o mutex para o acesso ao metadado do objeto.
    pthread_mutex_lock(&o_mgr->m_mutexmeta);
    if ( o_Hdr.VideoRate == 0 ) // Usa a taxa de transmissao default, se o
                                // metadados for antigo, e este campo estava
                                // igual a 0 (pois fazia parte do campo pad).
        *VideoRate = DEFAULTVIDEORATE; // Retorna a taxa default do video.
    else
        *VideoRate = o_Hdr.VideoRate;
    // Libera o mutex para o acesso ao metadado do objeto.
    pthread_mutex_unlock(&o_mgr->m_mutexmeta);
    return S_OK; // A funcao nao gera erros.
}

int RioObject::MapBlock	(	RioBlock	Block,
		int	RepBits,
		int *	numreps,
		RioDiskBlock *	reps
	)

Definition at line 518 of file ObjMapMgr.cpp.

{
    int rc = 0;
    int i, num;
    RioDiskBlock *p;

    num = 0;
    pthread_mutex_lock( &( o_mgr->m_mutexfast ) );

    if( o_Locked || !o_MapValid )
    {
        rc = ERROR_OBJECTMANAGER + ERROR_OBJECT_OPEN_FAILED;
        goto ret;
    }

    if( Block >= o_Hdr.nBlocks )
    {
        rc = ERROR_OBJECTMANAGER + ERROR_INVALID_LOGICAL_BLOCK;
        goto ret;
    }

    p = &o_Map[ o_Hdr.nRep * Block ];
    for( i = 0; i < o_Hdr.nRep; i++, p++, RepBits >>= 1 )
    {
        if( RepBits & 1 )
            continue;
        if( p->disk == 0 ) // skip null entries
            continue;
        memcpy( (char *) reps, (char *) p, sizeof( RioDiskBlock ));
        reps++;
        num++;
    }
ret:
    pthread_mutex_unlock( &( o_mgr->m_mutexfast ) );
    *numrep = num;
    if( num == 0 )
    {
        // if mapped to no blocks make an error
        return ERROR_RIOOBJECT+ERROR_INVALID_PHYSICAL_BLOCK;
    }
    return rc;
}

int RioObject::MarkDelete

(

)

Definition at line 457 of file ObjMapMgr.cpp.

{
    int rc;

    rc = SetSize(0, NULL, 0);    // release any blocks allocated
    if( rc )
        return rc;
    o_DeleteOnClose = 1;
    return 0;
}

RioObject& RioObject::operator=

(

const RioObject &

x

)

[private]

void RioObject::PrintHdr

(

)

[private]

Definition at line 725 of file ObjMapMgr.cpp.

{
    RioErr << "o_Hdr nRep " << o_Hdr.nRep
           << " BlockSize " << o_Hdr.BlockSize
           << " nBlocks "   << o_Hdr.nBlocks
           << " Size "      << o_Hdr.Size 
           << " VideoRate " << o_Hdr.VideoRate
           << endl;
}

int RioObject::ReallocBlocks	(	RioBlock	Block,
		unsigned long long int	ExcludeStorages
	)

Nova funcao usada para realocar os blocos associados ao ultimo bloco do arquivo associado ao objeto.

Este funcao e usada pelo objeto da classe Router ao reenviarmos um evento de escrita de um bloco no disco

Parameters:

	Block	numero do bloco a ser realocado.
	ExcludeStorages	vetor de bits com os servidores de armazenamento que nao devem ser usados. Cada bit i esta associado ao servidor com a ID i e um valor 1 neste bit indica que este servidor nao pode ser usado.

Returns:

S_OK se a realocacao dos blocos foi feita com sucesso e um valor diferente de S_OK se algum erro ocorreu.

Definition at line 902 of file ObjMapMgr.cpp.

{
    RioDiskBlock *PosLastBlock, *NewBlocks;
    int i, TotalBlocks, PosNewBlock, StorageId, rc = 0;
    unsigned long long int ExcludeStoragesNewBlocs;
    
    if( Block >= o_nMapBlocks ) // Bloco invalido.
        return ERROR_DISKMGR + ERROR_INVALID_BLOCK;
    else
    {
        // Inicializa o vetor de bits com os servidores que podem ser usados 
        // ao alocarmos os novos blocos.
        ExcludeStoragesNewBlocs = ExcludeStorages;
        // Aloca o vetor temporario que sera usado para realocar os blocos 
        // problematicos, associados aos discos cujos servidores de 
        // armazenamento nao podem ser usados.
        NewBlocks = new RioDiskBlock[ o_Hdr.nRep ];
        if( NewBlocks == NULL )
            return ERROR_DISKMGR + ERROR_MEMORY;
        // Obtem o mutex para o acesso ao metadado do objeto.
        pthread_mutex_lock( &o_mgr->m_mutexmeta );
        // Obtem acesso exclusivo as estruturas do objeto.
        pthread_mutex_lock( &o_mgr->m_mutexfast );
        // Obtem, no vetor com os enderecos dos blocos, a posicao dos blocos do 
        // bloco logico Block do arquivo.
        PosLastBlock= o_Map + ( Block * o_Hdr.nRep );
        // Descobre quais blocos sao problematicos, isto e, cujos discos estao
        // associados aos servidores de armazenamento que devem ser excluidos.
        TotalBlocks = 0;
        #ifdef RIO_DEBUG2
        RioErr << "RioObject::ReallocBlocks existem " << o_Hdr.nRep 
               << " replicacoes para o bloco " << Block << endl;
        #endif       
        for( i = 0; i < o_Hdr.nRep; i++ )
        {
            if( PosLastBlock[ i ].disk > 0 )
            {
                StorageId = ( PosLastBlock[ i ].disk - 1 ) / SNode::sn_maxdisks;
                #ifdef RIO_DEBUG2
                RioErr << "RioObject::ReallocBlocks verificando a replicacao "
                       << i + 1 << " do disco " << PosLastBlock[ i ].disk 
                       << " e o bloco " << PosLastBlock[ i ].block 
                       << " do servidor de armazenamento com a ID " << StorageId 
                       << endl;
                #endif       
                // Verifica se precisamos realocar o bloco fisico associado a 
                // replicacao i + 1.
                if( ( ExcludeStorages & ( 1ull << StorageId ) ) != 0 )
                {
                    #ifdef RIO_DEBUG2
                    RioErr << "RioObject::ReallocBlocks o bloco " 
                           << PosLastBlock[ i ].block << " associado ao disco "
                           << PosLastBlock[ i ].disk << " precisa ser "
                           << "realocado" << endl;
                    #endif       
                    // Em caso afirmativo, devemos realocar este bloco.
                    TotalBlocks++; 
                    // Libera o bloco e o invalida (faz o disco ser 0), para 
                    // sabermos, em seguida, quais blocos devem ser substituidos
                    // para o ultimo bloco logico.
                    rc = o_mgr->m_DiskMgr->Free( &PosLastBlock[ i ] );
                    if( rc )
                    {
                        #ifdef RIO_DEBUG2
                        RioErr << "RioObject::ReallocBlocks erro ao remover o " 
                               << "bloco " << PosLastBlock[ i ].block 
                               << " associado ao disco " 
                               << PosLastBlock[ i ].disk << ". Abortando o "
                               << "processo de realocacao" << endl;
                        #endif       
                        break;
                    }
                    // Invalida o disco para depois ser substituido por um novo
                    // disco.    
                    PosLastBlock[ i ].disk = -1;   
                }
                else
                {
                    // Em caso contrario, devemos desconsiderar, ao alocar os
                    // novos blocos, os discos deste servidor de armazenamento.
                    #ifdef RIO_DEBUG2
                    RioErr << "RioObject::ReallocBlocks o bloco " 
                           << PosLastBlock[ i ].block << " associado ao disco "
                           << PosLastBlock[ i ].disk << " esta ok. Igonrando " 
                           << "os discos do storage com a ID " << StorageId 
                           << " ao escolher os novos blocos fisicos" << endl;
                    #endif       
                    ExcludeStoragesNewBlocs = ExcludeStoragesNewBlocs |
                                              ( 1ull << StorageId );
                }
            }
            #ifdef RIO_DEBUG2 
            else
                RioErr << "RioObject::ReallocBlocks o disco da replicacao "
                       << i + 1 << " do vetor de replicacoes possui a ID "
                       << "invalida " << PosLastBlock[ i ].disk << endl;
            #endif           
        }
        
        if( ( !rc ) && ( TotalBlocks != 0 ) )
        {
            // Se precisamos alocar novos blocos e nenhum erro ocorreu ao
            // desalocarmos os blocos problematicos.
            
            rc = o_mgr->m_DiskMgr->AllocMult( TotalBlocks, NewBlocks, 
                                              ExcludeStoragesNewBlocs );

            if( !rc )
            {
                // Se erros nao ocorreram ao alocar os novos blocos, vamos 
                // entao substituir os blocos antigos pelos novos.
                PosNewBlock = 0;
                for( i = 0; i < o_Hdr.nRep; i++ )
                {
                    if( PosLastBlock[ i ].disk == -1 )
                    {
                        #ifdef RIO_DEBUG2
                        RioErr << "RioObject::ReallocBlocks realocando o bloco "
                               << " da replicacao " << i + 1 << endl;
                        #endif       
                        // Neste caso devemos substituir este bloco por uma
                        // das replicacoes.
                        if( PosNewBlock >= TotalBlocks )
                        {
                            // Isto e um erro, pois nao alocamos blocos 
                            // suficientes.
                            #ifdef RIO_DEBUG2
                            RioErr << "RioObject::ReallocBlocks numero "
                                   << "insuficiente de realocacoes ("
                                   << TotalBlocks << ")" << endl;
                            #endif       
                            rc = ERROR_DISKMGR + ERROR_UNEXPECTED;
                            break;
                        }
                        else
                        {
                            // Substitui um bloco problematico pelo novo 
                            // bloco.
                            PosLastBlock[ i ].disk = NewBlocks[ PosNewBlock ].
                                                                           disk;
                            PosLastBlock[ i ].block = NewBlocks[ PosNewBlock ].
                                                                          block;
                            
                            #ifdef RIO_DEBUG2                                              
                            RioErr << "RioObject::ReallocBlocks novo bloco "
                                   << "associado a realocacao " << i + 1 
                                   << ": disco = " << PosLastBlock[ i ].disk 
                                   << ", bloco = " << PosLastBlock[ i ].block 
                                   << endl;
                            #endif       
                            // Atualiza o numero de replicacoes usadas.
                            PosNewBlock++;
                        }
                    }
                    #ifdef RIO_DEBUG2
                    else if( PosLastBlock[ i ].disk == 0 )
                        RioErr << "RioObject::ReallocBlocks a replicacao " 
                               << i + 1 << " possui o disco com a ID "
                               << "reservada 0" << endl;
                    #endif           
                }
            }
            #ifdef RIO_DEBUG2
            else 
            {      
                RioErr << "RioObject::ReallocBlocks erro 0x" << hex 
                       << ( unsigned int ) rc << dec << " ao executar a "
                       << "funcao AllocMult" << endl;
            } 
            #endif
        } 
        else if( TotalBlocks == 0 )
        {
            // Neste caso retornamos sem salvar os metadados, pois nao alteramos
            // o mapa de blocos do objeto.
            #ifdef RIO_DEBUG2
            RioErr << "RioObject::ReallocBlocks a funcao foi chamada mas nao "
                   << "foi necessaria a realocacao dos blocos" << endl;
            #endif       
            // Libera o acesso exclusivo as estruturas do objeto.
            pthread_mutex_unlock( &o_mgr->m_mutexfast );
            // Libera o mutex para o acesso ao metadado do objeto.
            pthread_mutex_unlock( &o_mgr->m_mutexmeta );
            // Remove o vetor temporario usado ao realocarmos os blocos.
            delete NewBlocks;
            
            return ERROR_DISKMGR + ERROR_UNEXPECTED;       
        }
        #ifdef RIO_DEBUG2
        else 
        {      
            RioErr << "RioObject::ReallocBlocks erro 0x" << hex 
                   << ( unsigned int ) rc << dec << " ao executar a funcao "
                   << "Free" << endl;
        }
        #endif

        // O laco a seguir e necessario para permitir a remocao do arquivo
        // caso ocorra algum erro. Em caso contrario, nao conseguiremos remover
        // o arquivo e a formatacao do RIO sera necessaria, pois alguns blocos
        // fisicos poderiam ter um disco com a ID -1.        
        for( i = 0; i < o_Hdr.nRep; i++ )
            if( PosLastBlock[ i ].disk == -1 )
            {
                #ifdef RIO_DEBUG2
                RioErr << "RioObject::ReallocBlocks a replicacao " 
                       << i + 1 << " possui o disco com a ID invalida -1. " 
                       << "Mudando a ID para 0 para permitir a remocao do "
                       << "objeto associado ao bloco logico " << Block << endl;
                #endif       
                PosLastBlock[ i ].disk = 0;
                rc = ERROR_DISKMGR + ERROR_UNEXPECTED;       
            }
        
        // Define que o mapa foi alterado.
        o_MapChanged = 1;
        
        // Libera o acesso exclusivo as estruturas do objeto.
        pthread_mutex_unlock( &o_mgr->m_mutexfast );

        SaveObject();   // update obj hdr & map
        
        // Libera o mutex para o acesso ao metadado do objeto.
        pthread_mutex_unlock( &o_mgr->m_mutexmeta );
        
        // confirm disk allocations made (even if didn't finish)
        o_mgr->m_DiskMgr->Confirm();
       
        // Remove o vetor temporario usado ao realocarmos os blocos.
        delete NewBlocks;

        return rc;
    }
}

int RioObject::SaveObject

(

)

[private]

Definition at line 677 of file ObjMapMgr.cpp.

{
    int n, nbytes;
    int rc;

    n = lseek( o_FileHandle, 0, SEEK_SET );
    if( n != 0 )
    {
        rc = 1;
        goto err;
    }

    n = write( o_FileHandle, &o_Hdr, sizeof( o_Hdr ));
    if( n != sizeof( o_Hdr ) )
    {
        rc = 2;
        goto err;
    }

    if( o_MapChanged )
    {
        nbytes = o_Hdr.nRep * o_Hdr.nBlocks * sizeof( RioDiskBlock );
        n = write(o_FileHandle, o_Map, nbytes);
        if( n != nbytes )
        {
            rc = 3;
            goto err;
        }
        // ### might have gotten smaller, always truncate to "new" size
        nbytes += sizeof( o_Hdr );
        rc = ftruncate( o_FileHandle, nbytes );
        if( rc )
        {
            rc = 4;
            goto err;
        }
    }

    o_MapChanged = 0;
    return S_OK;

err:
    RioErr << "RioObject.SaveHeader failed for " << o_Name
           << " code " << rc << " " << strerror(errno) << endl;
    return ERROR_OBJECTMANAGER + ERROR_OBJECT_METADATA_WRITE;
}

int RioObject::SetSize	(	RioObjectSize	Size,
		char *	md5sum,
		unsigned long long int	ExcludeStorages
	)

Definition at line 566 of file ObjMapMgr.cpp.

{
    int result = S_OK;
    int result2;

    RioBlock nBlocks;

    // meta lock causes all metadata operations to be single thread
    // this also prevents multiple metadata operations on a single object
    // from happening at once...

    pthread_mutex_lock(&o_mgr->m_mutexmeta);

// O if abaixo foi retirado, pois a variavel o_Access nao e setada em lugar
// nenhum e o "RIO_SHARE_WRITE | RIO_SHARE_READ" sempre retorna erro, gerando
// um arquivo de zero byte na copia
//    if( o_Access & (RIO_SHARE_WRITE | RIO_SHARE_READ ) )
//    {
//        pthread_mutex_unlock( &o_mgr->m_mutexmeta );
//        return ERROR_NOT_EXCLUSIVE_ACCESS;
//    }

    nBlocks = ( Size + ( o_Hdr.BlockSize - 1 )) / o_Hdr.BlockSize;

    // deal with set to the existing size first (nothing to do)
    if( nBlocks == o_Hdr.nBlocks )
    {
        pthread_mutex_unlock( &o_mgr->m_mutexmeta );
        return S_OK;
    }

    if( nBlocks > o_Hdr.nBlocks )
    {
        result = Extend( nBlocks, ExcludeStorages );
    }
    else
    {
        result = Truncate( nBlocks );
    }

    // This was causing metadata inconsistency when the system was full
    // Changed as described next by Renato on July 03, 2000
    // If Extend() or Truncate() failed there was an error
    // when allocating or freeing blocks and object size should
    // be adjusted accordlingly.
    if( FAILED( result ) )
    {
        (*o_mgr->m_log)<< "Set Size Failed." << endl;

        // if number of blocks is greater than expected then Truncate() failed
        if( o_Hdr.nBlocks > nBlocks )
        {
            // Set new size to minimum of original size and current number of blocks
            if( ( o_Hdr.nBlocks * o_Hdr.BlockSize ) <  o_Hdr.Size )
            {
                Size = o_Hdr.nBlocks * o_Hdr.BlockSize;
            }
            else
            {
                Size = o_Hdr.Size;
            }
        }
        // if number of blocks is less than expected then Extend() failed
        if( o_Hdr.nBlocks < nBlocks )
        {
            // Set size to maximum possible with current allocated blocks
            Size = o_Hdr.nBlocks * o_Hdr.BlockSize;
        }
    }

    // -- change meta for object to new
    o_Hdr.Size = Size;

    // apply new md5sum
    if( md5sum == NULL )
        o_Hdr.nullmd5 = true;
    else
    {
        o_Hdr.nullmd5 = false;
        unsigned char md5_16bytes[16];
        for( int i = 0; i < 16; i++ )
        {
            if( md5sum[2*i] <= '9' )
                md5sum[2*i] -= '0';
            else
                md5sum[2*i] -= ('a' - 10 );

            if( md5sum[2*i+1] <= '9' )
                md5sum[2*i+1] -= '0';
            else
                md5sum[2*i+1] -= ('a' - 10 );

            md5_16bytes[i] = ((md5sum[2*i] << 4 ) | md5sum[2*i+1]);
        }
        memcpy( o_Hdr.md5sum, md5_16bytes, 16 );
    }

    // already done by Extend or Truncate   o_Hdr.nBlocks = nBlocks;
    result2 = SaveObject();
    pthread_mutex_unlock(&o_mgr->m_mutexmeta);

    if( FAILED( result ) )
        return result;
    else
        return result2;
}

int RioObject::SetVideoRate

(

unsigned int

VideoRate

)

SetVideoRate altera a taxa de transmissao (em Kbps) do video.

Parameters:

VideoRate

nova taxa de transmissao do video.

Returns:

o valor retornado pela funcao SaveObject()

Definition at line 882 of file ObjMapMgr.cpp.

{
    int result;
    // Obtem o mutex para o acesso ao metadado do objeto.
    pthread_mutex_lock(&o_mgr->m_mutexmeta);
    o_Hdr.VideoRate = VideoRate;
    result = SaveObject(); 
    // Libera o mutex para o acesso ao metadado do objeto.
    pthread_mutex_unlock(&o_mgr->m_mutexmeta);
    return result;
}

int RioObject::Truncate

(

RioBlock

nBlocks

)

[private]

Definition at line 804 of file ObjMapMgr.cpp.

{
    RioBlock n;
    RioDiskBlock *rep;
    int rc = 0;
    int i;

    pthread_mutex_lock( &o_mgr->m_mutexfast );

    // deallocate blocks from end of object
    o_MapChanged = 1;

    for( n = o_Hdr.nBlocks; n > nBlocks; n-- )
    {
        rep = &o_Map[ ( n - 1 ) * o_Hdr.nRep ];

        // DiskMgr knows which are real disk addresses,
        // just call him for each slot...
        for( i = o_Hdr.nRep-1; i >= 0;  i-- )
        {
            rc = o_mgr->m_DiskMgr->Free( &rep[i] );
            if( rc )
                goto quit;
        }

        // changed to fix bug
        // it was o_Hdr.nBlocks = n;
        o_Hdr.nBlocks = n - 1;
        // --------------------------------------------------------------------
    }

quit:

    pthread_mutex_unlock(&o_mgr->m_mutexfast);

    SaveObject();       // update obj hdr & map
    // always confirm as some may have worked...
    o_mgr->m_DiskMgr->Confirm();

    return rc;
}

---

Friends And Related Function Documentation

friend class ObjMapMgr [friend]

Definition at line 100 of file ObjMapMgr.h.

---

Field Documentation

bool RioObject::o_DeleteOnClose [private]

Definition at line 77 of file ObjMapMgr.h.

int RioObject::o_FileHandle [private]

Definition at line 76 of file ObjMapMgr.h.

ObjectHeader RioObject::o_Hdr [private]

Definition at line 85 of file ObjMapMgr.h.

bool RioObject::o_HdrValid [private]

Definition at line 84 of file ObjMapMgr.h.

bool RioObject::o_Locked [private]

Definition at line 83 of file ObjMapMgr.h.

RioDiskBlock* RioObject::o_Map [private]

Definition at line 81 of file ObjMapMgr.h.

bool RioObject::o_MapChanged [private]

Definition at line 78 of file ObjMapMgr.h.

bool RioObject::o_MapValid [private]

Definition at line 79 of file ObjMapMgr.h.

ObjMapMgr* RioObject::o_mgr [private]

Definition at line 74 of file ObjMapMgr.h.

char* RioObject::o_Name [private]

Definition at line 75 of file ObjMapMgr.h.

RioBlock RioObject::o_nMapBlocks [private]

Definition at line 80 of file ObjMapMgr.h.

---

The documentation for this class was generated from the following files:

• ObjMapMgr.h
• ObjMapMgr.cpp