Desenvolvimento Código Aberto

Você pode desenvolver aplicações escritas para o .NET Framework no Microsoft Visual Studio e utilizar os arquivos executáveis (“binários”) compilados no sistema operacional Windows, rodando-os diretamente no sistema operacional Linux através do Framework Mono.

O Mono contém as bibliotecas de desenvolvimento do núcleo do Framework da Microsoft e as ferramentas de desenvolvimento e implantação necessárias para portar suas funcionalidades, entretanto existe algumas limitações de portabilidade devido aos conceitos de cada sistema operacional, mas existe uma série de estratégias que você pode adotar, dependendo de como você está confortável com o uso do Linux.

Application Portability: http://www.mono-project.com/docs/getting-started/application-portability/

Distribuindo o Mono

Você pode distribuir o Framework Mono no Linux de um modo fácil, sem precisar ter contato manual com o repositório do projeto, utilizando um PPA (Personal Package Archive), o PPA é uma plataforma para disponibilizar pacotes de softwares empacotados por desenvolvedores para usuários do Ubuntu, você encontra os PPAs no site Launchpad, mantido pela empresa Canonical que é a desenvolvedora do Ubuntu Linux. Utilize as instruções abaixo no terminal do Linux para instalar o Framework Mono:

sudo apt-get install software-properties-common
sudo add-apt-repository ppa:inizan-yannick/mono
sudo apt-get update
sudo apt-get install mono-devel

Testando a Portabilidade: Windows – Linux

Para efetuar um teste de portabilidade, vamos criar uma aplicação básica no sistema operacional Windows utilizando o Microsoft Visual Studio, vamos escrever uma aplicação Windows Forms dinamicamente, utilizando algumas técnicas especificas, como alguns Event Handlers dinâmicos, Hot Keys e a previsão de teclas (Key Preview) do Windows e portar o aplicativo compilado que será executado no sistema operacional Linux.

1 – Crie uma nova solução Windows Forms chamada PortabilidadeCs e quando o formulário aparecer na tela aperte a tecla F7 para ir para a unidade de código csharp, troque o código da classe gerada automaticamente pelo código encontrado abaixo:

Windows – Aplicação – Visual Studio

2 – Compile e teste seu aplicativo, atente-se para o recurso de previsão de teclas do Windows utilizando as teclas A, B, C e D e também o recurso de teclas de atalhos utilizando as teclas ALT + A e assim por diante:

Aplicação – C# – .NET – Windows

3 – Após testar sua aplicação envie uma cópia do arquivo compilado PortabilidadeCS.exe para o sistema operacional Linux, você pode utilizar o método de sua preferencia para efetuar esta operação :

Aplicativo – C# – Linux

4 – Quando o Framework Mono está instalado no Linux, o sistema operacional reconhece arquivos de extensão EXE criados no .NET Framework como um arquivo executável do Linux. Utilize um duplo clique para executar sua aplicação C#:

C# – Portabilidade – Windows – Linux

Você pode perceber que todas as funcionalidades básicas do formulário funcionam perfeitamente. Agora você já pode portar suas aplicações Windows para outras plataformas, tenha em mente que você deve seguir sempre as melhores praticas para o desenvolvimento e respeitar as diferentes tecnologias de cada sistema operacional.

Uma opção é encontrar um meio termo para que suas aplicações .NET cruzem as mais diferentes plataformas sem que você tenha que reescrever seu código, por exemplo a tecnologia COM para Windows, mais especificamente DCOM é equivalente a tecnologia CORBA para Linux, porem é possível utilizar CORBA no Windows e portar seus aplicativos sem reescrever os arquivos binários que interagem entre si, dentro é claro, das diferenças e limitações existentes entre as duas tecnologias.

Corba: http://www.corba.org/

As classes comuns de pedido de arquitetura (CORBA) Broker são convertidas para as classes no namespace: System.Runtime.Remoting

Remoting: http://msdn.microsoft.com/pt-br/library/system.runtime.remoting(v=vs.110).aspx

Exemplo:

Neste exemplo criamos uma aplicação C# no Microsoft Visual Studio e a rodamos no sistema operacional Linux através do Framework Mono utilizando o mesmo arquivo “binário”.

C#

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace PortabiliadeCs
{
    public partial class Form1 : Form
    {
        // Define componentes dinamicamente
        Label rotulo;
        RadioButton soma;
        RadioButton subtrai;
        RadioButton multiplica;
        RadioButton divide;
        Label rotulo1;
        TextBox campo1;
        Label rotulo2;
        TextBox campo2;
        Button botao;
        TextBox texto;
        double total;

        public Form1()
        {
            InitializeComponent();

            // Evento OnShown do Formulario
            this.Shown += new System.EventHandler(this.Form1_Shown);
        }

        private void Form1_Shown(object sender, EventArgs e)
        {
            // Cria componentes dinamicamente no evento form shown
            rotulo = new Label();
            soma = new RadioButton();
            subtrai = new RadioButton();
            multiplica = new RadioButton();
            divide = new RadioButton();
            rotulo1 = new Label();
            campo1 = new TextBox();
            rotulo2 = new Label();
            campo2 = new TextBox();
            botao = new Button();
            texto = new TextBox();

            // posiciona componentes no form
            rotulo.Location = new Point(5, 10);
            soma.Location = new Point(5, 30);
            subtrai.Location = new Point(5, 50);
            multiplica.Location = new Point(5, 70);
            divide.Location = new Point(5, 90);
            rotulo1.Location = new Point(5, 120);
            campo1.Location = new Point(60, 120);
            rotulo2.Location = new Point(170, 120);
            campo2.Location = new Point(220, 120);
            botao.Location = new Point(330, 120);
            texto.Location = new Point(5, 150);

            // adiciona a propriedade de texto nos componentes
            rotulo.Text = "Escolha um RadioButton ou pressione (A, B, C ou D) ou (Alt + A, B, C ou D)";
            soma.Text = "Som&a";
            subtrai.Text = "Su&btrai";
            multiplica.Text = "Multipli&ca";
            divide.Text = "&Divide";
            rotulo1.Text = "Numero:";
            rotulo2.Text = "Numero:";
            botao.Text = "OK";

            // seta a propriedades para a caixa de texto
            texto.Multiline = true;
            texto.ScrollBars = ScrollBars.Vertical;
            texto.ReadOnly = true;

            // Define o tamanho dos objetos no form
            Form1.ActiveForm.Size = new Size(550, 400);
            rotulo.Size = new Size(450, 20);
            soma.Size = new Size(130, 20);
            subtrai.Size = new Size(130, 20);
            multiplica.Size = new Size(130, 20);
            divide.Size = new Size(130, 20);
            texto.Size = new Size(410, 100);
            rotulo1.Size = new Size(50, 20);
            rotulo2.Size = new Size(50, 20);
            texto.Size = new System.Drawing.Size(520, 200);

            // Define eventos para o checkbox
            soma.CheckedChanged += new System.EventHandler(soma_CheckedChanged);
            subtrai.CheckedChanged += new System.EventHandler(subtrai_CheckedChanged);
            multiplica.CheckedChanged += new System.EventHandler(multiplica_CheckedChanged);
            divide.CheckedChanged += new System.EventHandler(divide_CheckedChanged);
            botao.Click += new System.EventHandler(botao_Click);

            // Ativa a previsão de teclas do formulario
            Form1.ActiveForm.KeyPreview = true;

            // Nome do formulario
            Form1.ActiveForm.Text = "Desenvolvimento Aberto - Portabilidade Windows - Linux";

            // Adiciona componentes ao formulario
            Form1.ActiveForm.Controls.Add(rotulo);
            Form1.ActiveForm.Controls.Add(soma);
            Form1.ActiveForm.Controls.Add(subtrai);
            Form1.ActiveForm.Controls.Add(multiplica);
            Form1.ActiveForm.Controls.Add(divide);
            Form1.ActiveForm.Controls.Add(rotulo1);
            Form1.ActiveForm.Controls.Add(campo1);
            Form1.ActiveForm.Controls.Add(rotulo2);
            Form1.ActiveForm.Controls.Add(campo2);
            Form1.ActiveForm.Controls.Add(botao);
            Form1.ActiveForm.Controls.Add(texto);

        }

        // Eventos de Click dos botões
        private void botao_Click(object sender, EventArgs e)
        {
            if (soma.Checked)
            {
                total = Convert.ToDouble(campo1.Text) + Convert.ToDouble(campo2.Text);
                texto.AppendText(campo1.Text + " + " + campo2.Text + " = " + total + "\n");
            }

            if (subtrai.Checked)
            {
                total = Convert.ToDouble(campo1.Text) - Convert.ToDouble(campo2.Text);
                texto.AppendText(campo1.Text + " - " + campo2.Text + " = " + total + "\n");
            }

            if (multiplica.Checked)
            {
                total = Convert.ToDouble(campo1.Text) * Convert.ToDouble(campo2.Text);
                texto.AppendText(campo1.Text + " * " + campo2.Text + " = " + total + "\n");
            }

            if (divide.Checked)
            {
                total = Convert.ToDouble(campo1.Text) / Convert.ToDouble(campo2.Text);
                texto.AppendText(campo1.Text + " / " + campo2.Text + " = " + total + "\n");
            }
        }

        // Eventos do RadioButton - mudança de estado
        // Verifica o estado do componente pois este evento é executado duas vezes
        // 1 - Quando o botão é selecionado e
        // 2 - Quando o botão é deselecionado

        private void soma_CheckedChanged(object sender, EventArgs e)
        {
            if (soma.Checked)
            {
                texto.AppendText("Soma:\n");
            }
        }

        private void subtrai_CheckedChanged(object sender, EventArgs e)
        {
            if (subtrai.Checked)
            {
                texto.AppendText("Subtração:\n");
            }
        }
        private void multiplica_CheckedChanged(object sender, EventArgs e)
        {
            if (multiplica.Checked)
            {
                texto.AppendText("Multiplicação:\n");
            }
        }

        private void divide_CheckedChanged(object sender, EventArgs e)
        {
            if (divide.Checked)
            {
                texto.AppendText("Divisão:\n");
            }
        }     

        // Evento de tecla pressionada (Key Preview)
        private void Form1_KeyDown(object sender, KeyEventArgs e)
        {

            if (e.KeyCode == Keys.A)
            {

                if (soma.Checked == true)
                {
                    soma.Checked = false;
                }
                else
                {
                    soma.Checked = true;
                }

            }
            if (e.KeyCode == Keys.B)
            {

                if (subtrai.Checked == true)
                {
                    subtrai.Checked = false;
                }
                else
                {
                    subtrai.Checked = true;
                }

            }

            if (e.KeyCode == Keys.C)
            {

                if (multiplica.Checked == true)
                {
                    multiplica.Checked = false;
                }
                else
                {
                    multiplica.Checked = true;
                }

            }

            if (e.KeyCode == Keys.D)
            {

                if (divide.Checked == true)
                {
                    divide.Checked = false;
                }
                else
                {
                    divide.Checked = true;
                }

            }

        }
    }
}

Na verdade o termo “Linux Forms” não existe é só uma boa chamada para o post fazendo alusão ao Windows Forms, o termo correto é Gtk# (g-t-k-sharp). O  Gtk# é um Toolkit de interface gráfica do usuário para Mono e .Net. O projeto Gtk# liga o GTK+ toolkit e bibliotecas variadas do GNOME, permitindo o desenvolvimento de aplicações gráficas GNOME totalmente nativas utilizando os frameworks de desenvolvimento Mono e o .NET.

O que é GTK+ ?

O GTK+, ou o GIMP Toolkit, é um conjunto de ferramentas multi-plataforma para criar interfaces gráficas de usuário. Oferecendo um conjunto completo de widgets, o GTK+ é adequado para vários tipos de projetos desde pequenas ferramentas até para suítes completas de aplicativos.

GTK: http://www.gtk.org/

Desenvolvendo com  o GTK#

Tenha em mente que o projeto nativo para criar aplicativos equivalentes ao Windows Forms para Linux é o Gtk# apesar do Mono também suportar projetos criados no Windows Forms. O Gtk# e Windows Forms não são iguais possuindo varias diferenças entre si, desde o modo para criar aplicações gráficas em Design Time, até nas instruções C# que manipulam seus Widgets.

Hello World GTK#

1 – Para criar um projeto visual Mono para Linux utilizando Gtk#, abra o Mono Develop e crie um projeto GTK#, assim que a solução e o projeto forem criados, clique na unidade de código C# chamada MainWindow.cs e clique no botão Design:

Gtk# – Forms

2 – Os componentes do GTK# ao contrario do Visual Studio (Windows Forms) não herdam a classe Point e não possuem a propriedade Location, então você precisa aloja-los dentro de Widgets do tipo Containers. Na janela de propriedades arraste um componente Vbox para o formulário:

Vbox

3 – Na parte superior do Vbox, adicione um componente Menubar, na parte inferior adicione um componente Statusbar, adicione no meio um componente Table, crie os menus de modo similar ao Visual Studio e coloque um componente Label dentro do Statusbar, delete uma de suas colunas sobressalentes, dica, use o combobox da IDE quando precisar navegar pelos Widgets:

Menubar, Statusbar e Table

4 – Dentro das células da tabela coloque os componentes Labels, Entrys e Togglebutton, você pode adicionar ou apagar linhas e colunas na tabela clicando com o botão direito do mouse sobre ela e pode alinha-las utilizando a barra de tarefas do lado do combobox que mostra o componente com foco no qual você esta utilizando:

Layout – Widgets

5 – Na janela de propriedades, clique na aba Signals que é equivalente aos eventos no Visual Studio, Clique no botão e expanda a opção Button Signals, dê um duplo clique na propriedade Clicked, um evento equivalente ao evento OnClick do Visual Studio será criado na sua unidade de código C#:

Signals – Eventos

6 – Complete o código de sua unidade de código C# com o código encontrado logo abaixo, atente-se que criamos uma caixa de mensagem para o evento de clique do botão e apesar da sintaxe ser igual as instruções para realizar esta tarefa são diferentes, compile o código e teste o programa:

C# – Linux

Você verá que apesar das diferenças o  Mono funciona bem para Linux, é fácil e rápido desenvolver interfaces visuais de nível profissional. O Mono gera um arquivo executável com a extensão .exe para Linux, apesar da extensão não significar nada para o sistema operacional ainda assim é fácil para usuários leigos identificar programas executáveis para Linux.

Exemplo:

Neste exemplo criamos um aplicativo Mono utilizando o modelo de projeto Gtk#, você pode terminar o código implementando os eventos para os botões dos menus.

C#

using System;
using Gtk;

public partial class MainWindow: Gtk.Window
{
	public MainWindow () : base (Gtk.WindowType.Toplevel)
	{
		Build ();
	}

	protected void OnDeleteEvent (object sender, DeleteEventArgs a)
	{
		Application.Quit ();
		a.RetVal = true;
	}

	protected void OnTogglebutton1Clicked (object sender, EventArgs e)
	{

		// Cria uma caixa de menssagem (win forms = MessageBox)

                 String texto = "Nome: " + entry1.Text +
                                "\nSobrenome: " + entry2.Text +
                                "\nEndereço: " + entry3.Text;

	         // Cria dialogo
		MessageDialog dlg = new MessageDialog (null, DialogFlags.Modal, MessageType.Info, ButtonsType.Ok, texto);

		// chama dialogo
		dlg.Run ();

		// Destroi diaglogo
		dlg.Destroy();

		throw new NotImplementedException ();
	}
}

O .Net Framework da Microsoft é uma plataforma de software projetado para permitir que os desenvolvedores criem facilmente aplicações multi-plataforma, entretanto o suporte oficial da Microsoft limita-se ao sistema operacional Windows. Para que possamos portar aplicativos escritos em .Net Framework para outras plataformas além do Windows como, Linux, Mac OS X, iPhone OS, Oracle Solaris, FreeBSD e outros, precisamos utilizar a plataforma chamada Mono que é patrocinada pela empresa Xamarin. Podemos utilizar ainda uma IDE de desenvolvimento Open Source chamada MonoDevelop para criar programas em qualquer linguagem suportada pelo .Net Framework.

O que é Mono?

Mono é uma implementação open source do .NET Framework da Microsoft com base nos padrões ECMA para C# e Common Language Runtime. Uma família crescente de soluções e uma comunidade ativa e entusiasta que contribui e está ajudando o Mono a se posicionar como a principal escolha para o desenvolvimento de aplicações multi-plataforma.

Mono: http://www.mono-project.com/

O que é MonoDevelop?

É uma IDE multi-plataforma projetada principalmente para C# e outras linguagens .NET. O MonoDevelop permite aos desenvolvedores escrever rapidamente aplicações desktop e Web ASP.NET no Linux, Windows e Mac OSX. O MonoDevelop torna fácil aplicativos .NET que foram criados com o Visual Studio serem portados para Linux e Mac OSX mantendo uma única base de código para todas as plataformas.

MonoDevelop: http://monodevelop.com/

Instalando o Mono e o MonoDevelop

1- Para instalar o Mono no sistema operacional Linux podemos utilizar um PPA da Canonical para Ubuntu. Abra o terminal e digite os seguintes comandos:

sudo apt-get install software-properties-common
sudo add-apt-repository ppa:inizan-yannick/mono
sudo apt-get update
sudo apt-get install mono-devel

Mono -V para ver a versão

2 – Podemos instalar o MonoDevelop de um modo fácil pela GUI do Ubuntu, clicando no primeiro ícone do menu (pesquisa) e escrevendo a palavra “central”:

Pesquisa Ubuntu

3 – Abra a Central de programas do Ubuntu e digite a palavra MonoDevelop, em seguida selecione o programa e clique em instalar:

Instalando o MonoDevelop

4 – Após o termino da instalação abra o programa pelo ícone do Mono, que foi adicionado automaticamente ao menu e escolha criar uma Solução de Projeto Modo Texto, que é equivalente a um projeto de Console no Visual Studio:

Solução – Modo Texto

5 – A Solução e o projeto serão criados contendo o código de um tradicional programa Hello World, modifique de acordo com o programa abaixo e rode a aplicação que será executada no terminal do Linux:

Programa C# – Linux

Agora você pode utilizar os programas da categoria C# e portar para a plataforma Linux ou MAC OSX, clique no link a seguir para saber mais sobre a portabilidade do .NET Framework para o Mono.

Portabilidade: http://www.mono-project.com/docs/getting-started/application-portability/

Exemplo:

Neste exemplo instalamos a plataforma Mono, instalamos a IDE MonoDeveloper e criamos um tradicional programa HelloWorld.

C#

using System;

namespace NetLinux
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			Console.WriteLine ("Desenvolvimento Aberto!\n");
			Console.WriteLine ("Hello World Mono!");
		}
	}
}

Vamos aprender como manipular discos rígidos e partições no sistema GNU/Linux e como acessar seus discos de DVD-ROM e partições DOS, Windows no GNU/Linux.

Partições

São divisões existentes no disco rígido que marcam onde começa onde termina um sistema de arquivos. Por causa destas divisões, nós podemos usar mais de um sistema operacional no mesmo computador (como o GNU/Linux e o Windows), ou dividir o disco rígido em uma ou mais partes para ser usado por um único sistema operacional.

Pontos de Montagem

O GNU/Linux acessa as partições existente em seus discos rígidos e dvds através de diretórios. Os diretórios que são usados para acessar (montar) partições são chamados de Pontos de Montagem. No DOS cada letra de unidade (C:, D:, E:) identifica uma partição de disco, no GNU/Linux os pontos de montagem fazem parte da estrutura do sistema de arquivos raiz.

No GNU/Linux, os dispositivos existentes em seu computador (como discos rígidos, tela, portas de impressora, modem, etc) são identificados por um arquivo referente a este dispositivo no diretório /dev.

A identificação de discos rígidos no GNU/Linux é feita da seguinte forma:

/dev/hda1/

dev = Diretório onde são armazenados os dispositivos existentes no sistema.
hd = Sigla que identifica o tipo do disco rígido (hd=ide, sd=SCSI, xt=XT).
a = Letra que identifica o disco rígido (a=primeiro, b=segundo, etc…).
1 = Número que identifica o número da partição no disco rígido.

Exemplos de algumas identificações de discos e partições em sistemas Linux:

• /dev/hda – Primeiro disco rígido na primeira controladora IDE do micro (primary master).
• /dev/hda1 – Primeira partição do primeiro disco rígido IDE.
• /dev/hdb – Segundo disco rígido na primeira controladora IDE do micro (primary slave).
• /dev/hdb1 – Primeira partição do segundo disco rígido IDE.
• /dev/sda  -Primeira controlador de porta USB do sistema.
• /dev/sda1 – Primeiro dispositivo USB conectado a porta USB.
• /dev/sdb -O Segundo SCSI, SATA ou USB.
• /dev/sr0 – Primeiro DVD-ROM SCSI.
• /dev/sr1 – Segundo DVD-ROM SCSI.

Montando e acessando uma partição de disco

Você pode acessar uma partição de disco usando o comando mount:

mount [dispositivo] [ponto de montagem] [opções]

dispositivo:

Identificação da unidade de disco/partição que deseja acessar como /dev/hda1(disco rígido).

Ponto de montagem:

Diretório de onde a unidade de disco/partição será acessado. O diretório deve estar vazio para montagem de um sistema de arquivo. Normalmente é usado o diretório /mnt para armazenamento de pontos de montagem temporários.

Opções:

-t [tipo]

Tipo do sistema de arquivos usado pelo dispositivo. São aceitos os sistemas de arquivos:

ext2 – Para partições GNU/Linux usando o Extended File System versão 2 (a mais comum).

ext3 – Para partições GNU/Linux usando o Extended File System versão 3, com suporte a journaling.

reiserfs – Para partições reiserfs, com suporte a journaling.

vfat – Para partições Windows 95 que utilizam nomes extensos de arquivos e diretórios.

msdos – Para partições DOS normais.

iso9660 – Para montar unidades de CD-ROM. É o padrão.

umsdos – Para montar uma partição DOS com recursos de partições EXT2, como permissões de acesso, links, etc.

ntfs – Para partições NT File System.

Para mais detalhes sobre opções usadas com cada sistema de arquivos, veja a página de manual mount.

-r [tipo]

Caso for especificada, monta a partição somente para leitura.

-w [tipo]

Caso for especificada, monta a partição como leitura/gravação. É o padrão.

Caso você digitar mount sem parâmetros, serão mostrados os sistemas de arquivos atualmente montados no sistema.

Exemplo de Montagem:

Montar uma partição Windows (vfat) de /dev/hda1 em /mnt somente para leitura:

mount /dev/hda1 /mnt -r -t vfat

Montar uma partição DOS localizada em um segundo disco rígido /dev/hdb1 em /mnt:

mount /dev/hdb1 /mnt -t msdos

Montar um pen drive:

mkdir /mnt/pen
mount /dev/sdb /mnt/pen

fstab

O arquivo /etc/fstab permite que as partições do sistema sejam montadas facilmente especificando somente o dispositivo ou o ponto de montagem. Este arquivo contém parâmetros sobre as partições que são lidos pelo comando mount. Cada linha deste arquivo contém a partição que desejamos montar, o ponto de montagem, o sistema de arquivos usado pela partição e outras opções.

[Sistema de arquivos] [Ponto de Montagem] [Tipo] [Opções] [Dump] [Ordem]

Sistema de Arquivos: Partição que deseja montar.

Ponto de montagem: Diretório do GNU/Linux onde a partição montada será acessada.

Tipo: Tipo de sistema de arquivos usado na partição que será montada. Para partições GNU/Linux use ext2, para partições DOS (sem nomes extensos de arquivos) use msdos, para partições Win 95 (com suporte a nomes extensos de arquivos) use vfat,para unidades de CD-ROM use iso9660.

Especifica as opções usadas com o sistema de arquivos. Abaixo, algumas opções de montagem para ext2/3 (a lista completa pode ser encontrada na página de manual do mount):

• defaults – Utiliza valores padrões de montagem.
• noauto – Não monta os sistemas de arquivos durante a inicialização (útil para DVD-ROMS).
• ro – Monta como somente leitura.
• user – Permite que usuários montem o sistema de arquivos (não recomendado por motivos de segurança).
• sync é recomendado para uso com discos removíveis para que os dados sejam gravados imediatamente na unidade caso não seja usada, você deve usar o comando sync antes de retirar o disco da unidade.

Dump: Especifica a freqüência de backup feita com o programa dump no sistema de arquivos. 0 desativa o backup.

Ordem: Define a ordem que os sistemas de arquivos serão verificados na inicialização do sistema. Se usar 0, o sistema de arquivos não é verificado. O sistema de arquivos raíz que deverá ser verificado primeiro é o raíz “/” .

Após configurar o /etc/fstab, basta digitar o comando mount /dev/hdg ou mount /cdrom para que a unidade de CD-ROM seja montada. Você deve ter notado que não é necessário especificar o sistema de arquivos da partição pois o mount verificará se ele já existe no /etc/fstab e caso existir, usará as opções especificadas neste arquivo. Para maiores detalhes veja as páginas de manual fstab e mount.

Desmontando uma partição de disco

Para desmontar um sistema de arquivos montado com o comando mount, use o comando umount. Você deve ter permissões de root para desmontar uma partição.

umount [dispositivo/ponto de montagem]

Você pode tanto usar umount /dev/hda1 como umount /mnt para desmontar um sistema de arquivos /dev/hda1 montado em /mnt.

Desmontar o pen drive:

umount /dev/sdb

Observação: O comando umount executa o sync automaticamente no momento da desmontagem para garantir que todos os dados ainda não gravados serão salvos.