Miedo a perder la información

Miedo a perder la información

La información tiene valor, ya sean nuestras fotos del verano o un nuevo diseño industrial, está claro que para particulares y empresas es de vital importancia conservar la información, pero inherentemente a la tecnología va asociada la posibilidad de que un dispositivo electrónico falle o se estropee. Lo que en el caso que de este artículo ocupa  puede conllevar a perder para siempre una información valiosa que o bien puede suponer pérdidas al ser muy costoso o en caso de archivos personales tales como fotografías las cuales son únicas y difícilmente reproducibles.

Para proteger estos datos los cuales son importantes tuvieron que inventarse una serie de medidas de seguridad para la protección de los datos almacenados informáticamente, las medidas de seguridad, pueden ser hardware y software. Estas medidas comprenden desde formas ubicar geográficamente los datos, medidas de ubicación de datos como los sistemas Raid o software que respalde nuestro contenido.

En este artículo se destacaran principalmente las medidas software que hay disponibles para proteger información, haciendo un recorrido en anchura sobre las aplicaciones o sistemas más utilizados en la actualidad. El objetivo de este artículo es que pueda ser de utilidad para un público interesado en que medidas pueden encontrar.

Comenzaremos nombrado que las copias de seguridad pueden almacenarse físicamente en distintos dispositivos. Las cintas magnéticas son las más utilizadas para copias de seguridad completas de grandes sistemas tienen una gran capacidad pero una velocidad lenta de lectura y escritura ya que no se puede acceder a archivos en concreto  ya que físicamente es una cinta similar a las antiguas cintas de casete, estas necesitan ser rebobinadas. Por otro lado tenemos discos duros es una solución más cara pero que permite una mayor velocidad de escritura y lectura de las copias de seguridad. Otra opción a tener en cuenta son Sistemas de grabación en unidades ópticas permiten copias sistemas o partes de sistemas.

Actualmente en cuanto a copias de seguridad ha surgido multitud de empresas que han visto negocio en las copias de seguridad en la nube, estas empresas proporcionan copias en sus servidores, por una serie de tarifas, estas herramientas facilitan el trabajo a los administradores de sistemas además de que posibilita que la persona u organización que contrate estos servicios se olvide del almacenamiento físico y mantenimiento de los equipos informáticos necesarios para el almacenaje.

En referencia a las copias de seguridad locales (no en la nube), tenemos una serie de software disponibles como resync, el cual permite copias incrementales y compretas de una carpeta o sistema completo,  esta herramienta es interesante debido a que podemos hacerlo sin necesidad de apagar el equipo. Existen otras herramientas similares pero lo que se pretende destacar es la importancia de las herramientas de copia de seguridad con equipos en producción.

Copias de seguridad con equipos apagados, son copias completas de sistemas que permiten clonar discos duros o particiones completas estas herramientas son útiles para restaurar equipos a un punto concreto sin necesidad de formatear o realizar instalaciones. Ejemplos de este tipo de herramientas serian clonezilla o nortongost. Estos sistemas son muy utilizados por ejemplo para no tener que reinstalar un sistema operativo entero con sus software a varios usuarios estándar, si no que de esta forma es posible una única copia para todos los equipos.

Sin lugar a dudas existen innumerables sistemas de recuperación de datos, este artículo solo tiene como finalidad dar a un usuario no experto una visión de que existen posibilidades de proteger lo que muchas veces se teme perder una parte de nuestra organización o de nuestra historia, la cual gracias a la tecnología la podemos tener disponible en nuestros dispositivos electrónicos, y gracias a este tipo de herramientas sin miedo a perder esa parte de nuestra historia que se encuentra en forma de datos gracias a estas tecnologías de la información.

David García Martínez para seguridad Informática, Córdoba 14 de enero del 2015

Problemas Windows 8.1 y Autocad

Cuando tenemos autocad instalado  en widows 8 y actualizamos a 8.1 pude ser que nos encontremos  con un error en la licencia de AutoCad 2014. Hace pocos días me encontré con este error di mil "vueltas" por la red hasta que conseguí encontrar el siguiente vídeo:



Desde aquí quiero agradecer al autor el vídeo ya que gracias a el pude solucionar el problema sin tener que reinstalar el sistema entero.
Muchas gracias Omar Calixto

Proyecto Empresas Grado Medio

Hace tiempo cuando curse el ciclo de grado medio en informática me encargaron en una asignatura de economía que creáramos un plan de empresa en una web hoy después varios años la he vuelto a encontrar y quería compartir el enlace por si alguien esta cursando ese mismo ciclo o algún tipo de curso parecido le sirva.

En el podéis encontrar análisis económicos y financieros así como un plan completo de cómo se llevaría a cabo la empresa.

http://www.trabajoempresa.webuda.com/

Un  Saludo a todos.

Ejercicio Estrusctura de datos

Ejercicio para la clase de estructuras de datos

1. Inserta, en el orden especificado, los siguientes enteros en un ABOE aplicando las rotaciones pertinentes cuando corresponda: 11, 8, 18, 15, 13, 20, 7, 6, 10, 12 y 21.

2. Inserta, en el orden especificado, los siguientes enteros en un árbol (no hay que aplicar rotaciones, resultar á un ABOE): 11, 8, 7, 6, 10, 15, 13, 12, 20, 18 y 21. Borrar los siguientes enteros en el orden especificado, aplicando las rotaciones cuando corresponda: 7, 8, 11, 10, 15, 13, 12 y 21.

 Una vez terminado el ejercicio propuesto se propone este ejercicio de borrado:
Borrar el  5, 10 y 7

Multi programacion

4.    Multiprogramación

Es la técnica que permite que dos o más procesos ocupen la misma unidad de memoria principal y que sean ejecutados al “mismo tiempo” en la unidad central de proceso o CPU.

Aporta las siguientes ventajas:

·         Varios procesos en ejecución.

·         Permite el servicio interactivo simultáneo a varios usuarios de manera eficiente.

·         Aprovecha los tiempos que los procesos pasan esperando a que se completen sus operaciones de E/S.

·         Aumenta el uso de la CPU.

·         Las direcciones de los procesos son relativas, el programador no se preocupa por saber en dónde estará el proceso dado que el sistema operativo es el que se encarga de convertir la dirección lógica en física.

4.1.                   Partición de tamaño fijo

Si tenemos un sistema operativo mono usuario  la CPU aprovecharía  este aprovecharía mínimamente el rendimiento ya que al ser un único proceso por vez, si el sistema tiene  una entrada o salida, el tiempo de espera del sistema aumentaría considerablemente.  En el grafico de continuación se verá  una comparativa entre un sistema trabajando con un computo intensivo y un sistema ralentizado por entradas y salidas

Lo que se mejoro mediante “multiprogramación” es que esos tiempos de espera fuera utilizado por otros usuarios del sistema, por ejemplo ese tiempo que el sistema está esperando puede ser utilizado para procesos de otro usuario, lo cual conlleva que en memoria principal deba haber varios programas de forma simultánea.
La programación de tamaño fijo consiste  en crear una ilusión de simultaneidad  dividiendo la memoria principal en bloques de tamaño fijo el cual crea una ilusión de simultaneidad
Para saber  en qué parte de la memoria se encontraba cada programa se encargaban cada  partición relacionarla con un programa y dividirlo en sus procesos 
Para el SO. Resulta sencillo ya que todas las instrucciones de un mismo programan van a estar en la misma ubicación.

4.1.1.                       Carga absoluta y carga con reubicación

La reubicación de una partición de tamaño fijo se utiliza por ejemplo cuando la partición que se está utilizando se ha quedado pequeña y el programa necesita una partición de tamaño mas grande ya que al ser las particiones de tamaño fijo no se pueden ampliar .
Este procedimiento es más complejo ya que hay que tener en cuenta el tamaño de todas las particiones del sistema (en memoria principal) y de cuales están libres en cada ciclo, pero también tiene una gran ventaja que le da al sistema una mayor flexibilidad para distintos tipos de procesos.

4.1.2.                       Sistema de protección

Cuando se usa la asignación contigua de memoria la protección suele implementarse con varios registros de limites.

Los extremos de una partición pueden ir delineados con 2 registros o, también, indicados por el limite inferior o superior y el tamaño de la partición.

En el caso de que vayan delineados por 2 registros:

En el caso de que vayan indicados:

4.1.3.                       Inconveniente de la fragmentación

La fragmentación en el almacenamiento es algo que ocurre en cualquier sistema de independientemente de cómo se organice la memoria.

Normalmente este inconveniente se produce cuando:

·         Los trabajos del usuario no llenan completamente sus particiones designadas.

·         Una partición permanece sin usar porque es demasiado pequeña para alojar un trabajo que está en espera.

4.2.                   Partición de tamaño variable

Cuando se usa una partición de tamaño variable los procesos ocupan tanto espacio como necesitan, pero sin superar el espacio disponible en la memoria.

En particiones variables, no hay limites fijos de memoria, luego la partición de un trabajo es un propio tamaño.

Se consideran “esquemas de asignación contigua”, ya que un programa debe ocupar las posiciones adyacentes de almacenamiento.

Una vez que los procesos terminan dejan disponibles espacios de memoria principal entre los cuales hay otros procesos, estos se pueden denominar “agujeros”.

Estos agujeros pueden ser usados por otros procesos o trabajos y que cuantos estos terminan dejan otros agujeros más pequeños. Esto de forma sucesiva provoca que los agujeros sean cada vez más numerosos provocando un mayor desperdicio de memoria.

Estos agujeros se pueden combinar o fusionar, de forma que cuando un proceso termina y el almacenamiento que libera tiene limites con otros agujeros, combina o fusiona con todos los agujeros adyacentes formando uno solo.

Trabajo voluntario de concurrencia - Fumadores SO 12/13

He aquí el pseudocódigo de la práctica voluntaria:




-- Fumadores --

-- Definición de tipos --

definir TIPOS 3
definir ITERACIONESF 20
definir ITERACIONESP 50
definir FUMADORES    3

-- Variables globales --

entero         fumadores[TIPOS][TIPOS];
entero         mesa[TIPOS];
caracter     traduccion[TIPOS][100]={"cerillas","papel","tabaco"};


-- Semaforos --

semaforo mutex,necesidad,producido;

-- Prototipo de funciones --

vacio *fumador(vacio *id);
vacio *productor();
vacio cogerLoQueNecesito(entero id);

-- Programa pincipal --

entero principal()
{
    hilo hiloProductor[1];
    hilo hilosFumadores[FUMADORES];
    entero i,id[FUMADORES];estado;
   
    variableExterna semaforo mutex, necesidad, producido;
    variableExterna entero fumadores[TIPOS][TIPOS],mesa[TIPOS];
   
    random(tiempo(NULO));
   
    -- Inicializacion de variables --
    -- FUMADOR 0
    fumadores[0][0]=0; fumadores[0][1]=25; fumadores[0][2]=25;
    -- FUMADOR 1
    fumadores[1][0]=25; fumadores[1][1]=0; fumadores[1][2]=25;
    -- FUMADOR 2
    fumadores[2][0]=25; fumadores[2][1]=25; fumadores[2][2]=0;
    -- MESA
    mesa[0]=0; mesa[1]=0; mesa[2]=0;

    iniciar_semilla(&mutex,1,0);
    iniciar_semilla(&necesidad,1,1);
    iniciar_semilla(&producido,1,0);
   
    Si ((estado = crear_hilo(&hiloProductor[0],Nulo,productor,Nulo)))
    Salir (estado);
   
    Para(i=0;i<FUMADORES;i++)
    {
        id[i]=i;
        Si ((estado = crear_hilo(&hilosFumadores[i],Nulo,fumador,(vacio *) &id[i])))
        Salir (estado);
    }
   
    union_hilo(hilosFumadores[i], Nulo);
   
    Para(i=0;i<FUMADORES;i++)
    {
        union_hilo(hilosFumadores[i],Nulo);
    }
    devolver(0);
}

vacio *fumador(vacio *id)
{
    entero *nombre, i, j, vez=0;
   
    variableExterna semaforo mutex,necesidad,producido;
   
    nombre=(int *) id;
   
    Escribir("Comienza el fumador *nombre");
   
    Para(i=0;i<ITER;i++)
    {
        semaforoEsperar(&producido);
        cogerLoQueNecesito(*nombre);
       
        mientras(fumador[*nombre][0]>0 && fumadores[*nombre][1]>0 && fumadores[*nombre][2]>0)
        {
            Para(j=0;j<TIPOS;j++)
            {
                fumadores[*nombre][j]-=1;
                vez++;
                Escribir("El fumador *nombre esta fumando vez");
            }
        }
       
        dormir(2);
       
        Escribir("El fumador *nombre necesita coger cosas");
        semaforoEnviar(&necesidad);
       
       
           
    }
    hiloSalir(Nulo);
}
   
vacio *productor()
{

    entero i,tipo,U;
   
    variableExterna semaforo mutex,necesidad,producido;
    variableExterna entero mesa[TIPOS];
    variableExterna caracter traduccion[TIPOS][100];
   
    para(i=0;i<ITERACIONESP;i++)
    {
        semaforoEsperar(&necesidad);
        semaforoEsperar(&mutex);
       
        tipo=random()%3;
        U=random()%10;
        mesa[tipo]+=U;
        Escribir("Productor produjo traduccion[tipo] --> U");
       
        semaforoEnviar(&mutex);
        semaforoEnviar(&producido);
    }
    hiloSalir(Nulo);
}

vacio cogerLoQueNecesito(entero id)
{
    entero j, cogido=;
   
    variableExterna semaforo mutex, producido;
    variableExterna mesa[TIPOS], fumadores[TIPOS][TIPOS];
    variableExterna caracter traduccion[TIPOS][100];
   
    semillaEsperar(&mutex);
    Para(j=0;j<TIPOS;j++)
    {
        Si(fumadores[id][j]==0)
        {
            Si(mesa[0]>0)
            {
                fumadores[id][j]=mesa[j];
                Escribir("El Fumador (id) cogió mesa[j] de traduccion[j]");
                mesa[j]=0;
                cogido=1;
            }
        }
    }
    semaforoEnviar(&mutex);
}


He aquí el código en C de los fumadores:



//Ejercicio voluntario fumadoress !!

//Librerias nesesarias
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <semaphore.h>
#include <time.h>

//DEFINES
#define TIPOS 3 //cerillas-tabaco-papel
#define ITER 20 //iteraciones del fumador
#define ITERP 50 //Iteraciones del productor
#define F 3 //Numero de fumadores

//Variables globales
int f[TIPOS][TIPOS];
int mesa[TIPOS];
char traducion[TIPOS][100]={"serillas", "Papel", "Tabaco"};

//Semaforos
sem_t mutex,nesesidad,producido;


//Prototipos de funciones
void *fumador(void *id);
void *productor();
void cojerLoQueNesesito(int id);

//Programa principal
int main()
{
    pthread_t hiloP[1];
    pthread_t hilosF[F];
    int i,id[F],status;

    extern sem_t mutex, nesesidad, producido;
    extern int f[TIPOS][TIPOS],mesa[TIPOS];

    srand(time(NULL));

    // **** Inicializaci�n de variables ****
    //FUMADOR 0
    f[0][0]=0; f[0][1]=25; f[0][2]=25;
    //FUMADOR 1
    f[1][0]=25; f[1][1]=0; f[1][2]=25;
    //FUMADOR 2
    f[2][0]=25; f[2][1]=25; f[2][2]=0;
    //mesa
    mesa[0]=0; mesa[1]=0; mesa[2]=0;

    //SEMAFOROS
    sem_init(&mutex, 1, 0);
    sem_init(&nesesidad, 1, 1);
    sem_init(&producido, 1, 0);

    //hilo productor
    if ((status = pthread_create(&hiloP[0], NULL, productor, NULL)))
        exit(status);

    for(i=0;i<F;i++)
    {   
        id[i]=i;
        if ((status = pthread_create(&hilosF[i], NULL, fumador, (void *) &id[i])))
            exit(status);
    }

    //esperar hasta finalizar el productor
    pthread_join(hiloP[0], NULL);

   
    //esperar hasta finalizar los hilos fumadores
    for (i = 0; i < F; i++)
    {
        pthread_join(hilosF[i], NULL);
    }

    return (0);
}
//funcion para los fumadores
void *fumador(void *id)
{
    int *nombre, i, j, vez=0;

    extern sem_t mutex, nesesidad, producido;
   
    nombre=(int *) id;

    printf("\nComienza el fumador %d", *nombre);

    for(i=0;i<ITER;i++)
    {
        sem_wait(&producido); //Espera hasta que el productor haya producido algo

        //comprueba que es lo que nesesita y si nesesita algo lo coje
        cojerLoQueNesesito(*nombre);


        while(f[*nombre][0]>0 &&f[*nombre][1]>0 &&f[*nombre][2]>0) //fuma mientras tenga
        {
            for(j=0;j<TIPOS;j++)//Gasta una unidad de cada cosa           
                f[*nombre][j]-=1;
            vez++;
            printf("\nEl fumador %d esta fumado %d", *nombre, vez);
        }

        //ha este punto solo se llega si no se tiene nada mas qu fumar
        sleep(2);
        printf("\nElfumador %d nesesita coger cosas", *nombre);

        sem_post(&nesesidad); //Espera hasta que el productor haya producido algo
    }
    pthread_exit(NULL);
}

//funcion para el poductor
void *productor()
{
    int i,tipo,U;

    extern sem_t mutex, nesesidad, producido;
    extern int mesa[TIPOS];
    extern char traducion[TIPOS][100];

    for(i=0;i<ITERP;i++)
    {
        sem_wait(&nesesidad);//Espera ha que el fumador nesesite algo
        sem_wait(&mutex);

        tipo=rand() %3;
        U=rand() %10;
        mesa[tipo]+=U;   
        printf("\nProductor produjó %s --> %d", traducion[tipo], U);

        sem_post(&mutex);
        sem_post(&producido);//Indica que ya hay nuevas cosas producidas
    }

    pthread_exit(NULL);
}

//Esta funcion solo coje lo que el fumador nesesita
void cojerLoQueNesesito(int id)
{
    int j, cojido=0;

    extern sem_t mutex, producido;
    extern int mesa[TIPOS], f[TIPOS][TIPOS];
    extern char traducion[TIPOS][100];

    sem_wait(&mutex);
    for(j=0;j<TIPOS;j++)
    {
        if(f[id][j]==0)
        {
            if(mesa[0]>0)
            {
                f[id][j]=mesa[j];
                printf("\n\nEl Fumador %d cojió %d de %s ", id, mesa[j], traducion[j]);
                mesa[j]=0;
                cojido=1;
            }
        }
    }
    sem_post(&mutex);
}

hibernar en WINDOWS 8

Para todos aquellos que nos gusta la opción de hibernar para poder seguir con nuestro trabajo en windows 8 esta desestabilizar por eso os explico como activarla

panel de control --> opciones de energía --> elegir comportamiento de la tapa

pulsamos sobre cambiar configuración y ya podremos volverlo a activar.