Emulador de partições baseado em arquivos

Shareware

Grátis para testar e avaliar

O desenvolvedor não informa as limitações da versão de testes, a versão completa pode ser adquirida por US$25,00

Emulador de partições baseado em arquivos. Todos os dados armazenados nas partições emuladas são armazenados em um arquivo. Deste modo, você poderá criar um disco emulado sem se preocupar em fazer alterações nas partições do HD. Permite não apenas armazenar arquivos como documentos, músicas, vídeos e etc. como também instalar programas nas partições emuladas. Possibilita também a criação de uma partição emulada com recursos de encriptação. Quando dados são escritos nessa partição, são automaticamente encriptados e armazenados no arquivo. Desta forma, ninguém poderá acessar os dados dessa partição sem conhecer a senha.

Roda em Windows NT, 2000, XP, 2003, Vista

Disponível nos idiomas Inglês

Download WinDiskXP

Linux Embedded จำเป็นต้องมี File System สำหรับลงโปรแกรม
แต่เนื่องจากการใช้งานในลักษณะ Home Appliance ที่ต้องปิดเปิดไฟ AC โดยไม่สั่ง shutdown โดยหลีกเลี่ยงไม่ค่อยไ้ด้ (หรือได้ ?)
ทำให้ทุกครั้งที่ boot เครื่องใหม่ต้องนั่งรอ check disk ทุกครั้งเสียเวลา .. เสียข้อมูล

ทางแก้ก็มีอย่างเช่นใช้ File System ที่มีการเก็บ Journal List เป็นระยะ

ซึ่งสำหรับ PC ทั่วไปจะใช้ ext3 ก็พอใช้ได้ .. เหมาะกับ file system ใหญ่ๆ

สำหรับ Wireless Router ที่เป็น Linux base จะใช้ jfs ซึ่งก็ช้าเอาการอยู่
http://www.debian-administration.org/articles/388
http://linuxgazette.net/102/piszcz.html

แต่สำหรับงาน TS7400 อยากแนะนำ ReiserFS ที่ดีกว่าในแง่ความทนทานต่อไฟดับ (จากการทดลองใน RTU ตัวเก่า Advantech)
ถึงแม้จะช้ากว่า ext3 เมื่อขนาดของ Partition ใหญ่กว่า 512mb, และ file มีขนาดใหญ่

จึงอยากให้ลองพิจารณาใช้กันดู

ps. หากต้องการหาข้อมูลสำหรับการทำ File system ใน flash memory ให้ดูจาก
http://www.numonyx.com/en-US/ResourceCe … nuxFS.aspx

ps2. หากไม่สนใจความถูกต้องของข้อมูล (data integrity) เราสามารถใช้ fs2tune เพื่อสั่งให้ไม่มีการ check disk ตอน boot ได้

Technorati : file system, linux, power loss
Del.icio.us : file system, linux, power loss

I recently encountered an interesting issue on Mac OS X. One of the applications I was working on, transfers files to a server. The transfer program first compresses the file using zip algorithms (zlib) and then sends the files to the server via a socket connection. Everything worked well except for some files. These files had extended attributes. HFS/HFS+ filesystems on Mac OS support extended attributes for files. These attributes are metadata that the application creator adds to the files. You can read more about extended attributes from the wikipedia link above.

The following commands to view the extended attributes on files -

$ ls -l@

The above command displays the extended attribute names (if they exist) for each of the files in the directory.

Another command that can be used is -

$ xattr <filename>

The above command can be used to list/add/delete extended attributes.

For some applications stripping off the extended attributes doesn’t make a difference to their functionality. But for others these are essential. Examples of some extended attributes are “com.apple.FinderInfo”, “com.apple.ResourceFork“. The FinderInfo is used by the Mac OS Finder.

Some applications don’t handle extended attributes well one such application being zip. Copying such files to file systems that don’t support extended attributes also result in loss of information. “rsync” has options to copy files with extended attributes. One other thing that is misleading is that these extended attributes don’t contribute to the file-size when viewed via a shell (ls command, stat command etc.). I could only see the difference when viewed via spotlight information. And the checksum of the file remains the same with and without the extended attributes.

However tar doesnt have a problem in keeping the attributes intact.

One way to circumvent the stripping of these attributes is to tar and then zip the files before transfer or write a program that uses getattrlist and setattrlist to handle these attributes separately.

Other useful references for extended attributes and acls -

http://forthescience.org/blog/2007/12/11/macosx-leopard-extended-ls/

http://www.macgeekery.com/tips/the_new_resource_fork

http://lists.apple.com/archives/Filesystem-dev/2009/jul/msg00011.html

http://lists.samba.org/archive/rsync/2007-March/017528.html

NILFS is a new implementation of a log-structured file system (LFS) supporting continuous snapshotting. In addition to versioning capability of the entire file system, users can even restore files mistakenly overwritten or destroyed just a few seconds ago. Since NILFS can keep consistency like conventional LFS, it achieves quick recovery after system crashes.

read more…

Existe uma classe na plataforma .Net chamada FileSystemWatcher que permite que o sistema acompanhe as alterações de uma ou mais pastas.

Como monitorar uma pasta:

1. Criar uma instância de FileSystemWatcher (ofso)
2. Definir se os subdiretórios também serão monitorados com a propriedade ofso.IncludeSubdirectories = true
3. Definir os filtros que serão usados, alterando a propriedade ofso.NotifyFilter
   - Os filtros são separados por pipe (|).
   - Ex.: NotifyFilters.FileName | NotifyFilters.LastWrite
4. Criar handlers e métodos que forem necessários à monitoração.
5. Alterar a propriedade EnableRaisingEvents para true.
   - Isso dá início ao monitoramento.

With Data Recovery Wizard Professional files can be recovered from a reformatted or corrupted volume. This is even possible when the volume has been deleted and its original position and size are unknown. Data Recovery Wizard Professional can scan an entire physical hard drive to look for traces of defunct volumes.

EaseUs Data Recovery Wizard Professional can recover data from:

Here are some key features of “EaseUs Data Recovery Wizard Professional”:

Download LInk:
EASEUS Data Recovery

There always seems to be the question “what do I do with a .bin and .cue file” in these forums so I figured I would write a quick and simple tutorial. Please feel free to add more. So you have downloaded two files, one with a .bin extension and one with a .cue extension. “What do I do with these?” you ask. There are a number of options. BURN TO CD You will need either NERO, CDRWIN or FIREBURNER to burn the file. To burn with NERO: Start NERO, choose FILE, choose BURN IMAGE, locate the .cue file you have and double click it. A dialog box will come up, for anything other than music make sure you choose DISC-AT-ONCE (DAO). You can also turn off the simulation burn if you so choose. Then burn away. To burn with CDRWin: Start CDRWin, choose the button on the top left, choose LOAD CUESHEET, press START RECORDING. To burn with Fireburner: Start Fireburner, click on the button on the bottom left corner “VISUAL CUE BURNER/BINCHUNKER”, press the right mouse button and choose LOAD TRACKS FROM .CUE and choose the correct .CUE file, press the right mouse button again and chooseselect “Burn/Test Burn”, choose DISK AT ONCE (DAO), disable TEST BURN and MULTISESSION, press OK. .CUE ERRORS The most common error you will get with a .cue file is when it points to an incorrect path. This is easily fixed. Find the .bin file, copy the exact title including the .bin extension. Now find the .cue file, open the .cue file using notepad. It should look similar to this: FILE “name of file.bin” BINARY TRACK 01 MODE2/2352 INDEX 01 00:00:00 TRACK 02 MODE2/2352 INDEX 00 00:04:00 INDEX 01 00:06:00 Delete everything in the quotes, in this case we would delete name of file.bin. Now place the title you copied in between the quotes. Save the changes and close out. Thats it, your .cue file should work now. OTHER WAYS TO USE .BIN & .CUE FILES VCDGear: This program will allow you to extract MPEG streams from CD images, convert VCD files to MPEG, correct MPEG errors, and more. Daemon Tools: This program creates a virtual drive on your PC which will allow you to “mount” the .cue file and use whatever is in the .bin file without having to burn it to a cd. ISOBuster: This program will allow you to “bust” open the .bin file and extract the files within the .bin.

Continuing our seven-part blog mini-series entitled “7 Things You Need to Know About Oracle 11gR2″, Integra Senior DBA Jason Buchanan, recently one of just twelve people from around the world hand-picked by Oracle to participate in the Oracle 11gR2 final beta, discusses Oracle 11gR2 ASM (Automatic Storage Management):

One of the biggest enhancements in Oracle Database 11g Release 2 is Oracle Automatic Storage Management Cluster File System (Oracle ACFS). You can now leverage the strength of your database storage infrastructure to house not only your database files but also your Oracle homes and other non-Oracle file types. ACFS greatly reduces the complexity of retrieving backups and Data Pump exports if they are stored in ACFS filesystems. Another new ASM feature is ADVM (ASM Dynamic Volume Manager) – ADVM provides the means to dynamically resize ACFS volumes on the fly without downtime.

Best of all, the high availability features of your storage infrastructure can be put to use as a destination for your Oracle binaries and other critical files. The conundrum of what to do with the interior one-third of your disk spindles can be mitigated by using this space to create an important, but lesser-used ASM diskgroup: a new diskgroup for your Oracle homes. You’ll still need to install the Grid Infrastructure binaries on local disk, but a single shared Oracle home is very easy to implement with ACFS.

The optimal way to manage ACFS is via a new Grid Infrastructure utility named “asmca” which is located in the Grid Infrastructure home directory. You must change your ORACLE_HOME (and preferably your path) to point to the Grid Infrastructure directory to use the utility.  The asmca utility represents a new approach to Oracle’s Java GUIs with an updated appearance and simpler design. The tool allows you to administer all of your ASM objects and manage ADVM objects.

As a side note, non-RAC environments will not auto-start ACFS objects. You will need to write a script to start ACFS after booting, after which you can mount your ACFS volume. The command to start the ACFS driver is “acfsload start -s” – Oracle will take it from there after starting ACFS. It’s interesting that Oracle Grid Infrastructure will create init scripts for OHASD (Oracle High Availability Services Daemon) but not ACFS; however, it’s simple enough to run acfsload from a new startup script.

Oracle 11gR2 documentation is more robust than ever, and Oracle ACFS is very well documented:

http://bit.ly/11gR2ASMDocs

Please check back soon for Jason’s next entry in this blog series: “How to Streamline Your Oracle 11gR2 Installation Process”.

Also, please join Integra CTO Allan Edwards and Jason Buchananon Tuesday November 3, 2009 at 12:00 pm Eastern / 9:00 am Pacific for a live webcast entitled “Safe Passage to Oracle 11g: Lessons from Recent Upgrades“. In this important 30-minute webcast, Allan, Jason, and other Integra consultants will share critical lessons learned during a number of recent real-world 11g upgrade projects. What you learn in this webcast can make the difference between success and disaster, so please register now for the webcast at http://bit.ly/11gWebcast!

As always, I’d love to hear your thoughts and comments here, or on our Facebook discussion board!

Thanks!

Eric Heine
Vice President
Integra Technology Consulting

781-890-0070
eheine at integratc dot com

www.integratc.com

Follow us on Twitter: twitter.com/IntegraTC

ZFS - The Last Word in File Systems?

MacWorld has decided to wade through the murky waters of Apple’s discontinuation of porting Sun Microsystems ZFS to Mac OS X Snow Leopard. Read more here:

Mac port of ZFS discontinued

Posted using ShareThis

ZFS - The Last Word in File Systems?

Louis Gerbarg has posted an excellent summation of the Apple & Sun ZFS Controversy. Read more here:

The loss of ZFS.

Caros toda as explicações aqui são apenas básicas, eles servem para que voce tenha o conhecimento suficiente para a escolha do melhor sistema de arquivos para o seu computador residencial e também não tenho a pretensão de dizer qual seria a melhor escolha (isso só voce poderá dizer com base em testes)

O que é sistema de arquivos:

Sistema de arquivos é um conjunto de rotinas e estruturas que permite ao sistema operacional ter o controle do acesso aos dados nas unidades de armazenamento.

- Journaling (subst. diário) é a criação de um log com informações sobre os arquivos armazenados no disco como metadata(tamanho, dono e permissões) e as informações dos dados em si, metadadata não é o arquivo propriamente dito é apenas a informação estrutural do mesmo

- EXT3 é a terceira versão do sistema de arquivos EXT que é a mais utilizada hoje em dia, devido a sua maior segurança e ser a evolução do primeiro sistema de arquivos para linux o EXT, ele é considerado o mais seguro (me refiro a integridade dos arquivos) pelo fato do seu sistema de journaling armazenar as informações de metadados e dos dados com isso fazendo com que a recuperação dos dados caso haja um desligamento acidental seja mais eficiente, o sistema de journal do EXT3 possui três modos:

Ordered (padrão) – o journal é atualizado no final de cada operação de escrita, o que diminui o desempenho pelo fado da cabeça fazer a gravação dos dados duas vezes

Wirtebkack – ele armazena apenas informações referente a metadata, o que o tornar o mais rápido dos três modos, mais o torna o mais suscetível a falhas durante um processo de recuperação de arquivos

Journal – é o modo mais seguro e confiável do três (torno a lembrar que é somente a respeito da recuperação dos dados) devido ao fato dele armazenar as informações tando de metadada assim como informações sobre os dados que serão armazenados no disco é o modo que tem o menor desempenho dos três e é o menos utilizado.

- ReiserFS é um sistema de arquivos que tem como característica positiva a utilização de blocos dinâmicos, que nada mais é que to tamanho do bloco aonde o arquivo ira ficar é sempre igual ao seu tamanho (repere no seu computador a propriedade do arquivo e veja que há duas notações uma ao tamanho do arquivo e a outra do tamanho em disco) com o RiserFS isso não ocorre do arquivo ocupar mais espaço em disco do que o necessário, já que o tamanho de cada bloco é ajustado para que o arquivo não ocupe o mais espaço do que o necessário e uma característica negativa (que não pode faltar) é que ele dentre os outros sistemas de arquivos para linux é o que utiliza um maior percentual de processamento, pelo fato dos seus algorítimos serem um pouco mais complexos.

- XFS é um sistema de arquivos de grande desempenho principalmente para arquivos grandes, desenvolvido inicialmente para Unix e adaptado para o linux ele utiliza endereçamento de 64 bits (permite arquivos maiores e aumenta o desempenho do mesmo), possuir journal que grande uma grande velocidade na recuperação dos dados.

- JFS assim como XFS ele é um sistema de arquivos 64 bits ele tem como um característica interessante a capacidade de redimensionar as partições do sistema sem que o computador seja desligado, ele não é muito utilizado pelo fato dele ter um inicio um tanto quanto conturbado devido a grande quantidade de bugs que existia nele, que hoje já foram sanados

- FAT é um sistema de arquivos que foi desenvolvido pela Microsoft para o MS-DOS, que hoje só é utilizado por pen-drivers e outros discos de estado solido (SSD em inglês) como cartões de memória e é virtualmente suportado por todos os sistemas operacionais conhecidos.

- NTFS é o sistema de arquivos mais atual da Microsoft que foi desenvolvido para substituir o FAT devido a falta de segurança e pela sua limitação a reconhecer apenas discos com apenas 2 Gbs, ele assim como os sistemas de arquivos para o linux possui um sistema de recuperação de dados que aumenta as chances de voce recuperar os seus dados e ele teve uma serie de implementações de segurança como o permissões de acesso aos arquivos armazenados no disco.

Amplexos e até o próximo post

PS.: Fiquei tanto tenpo sem posts deivo a falta de moden

Then you probably want Xfile.  This tool is especially useful for system administrators or developers.  Click here to learn more.  A free test drive program is available now.

DESCRIZIONE – Tentando di spostare un file di circa 8GB su un HD esterno ottenevo sistematicamente al termine l’errore 1309 e quindi il conseguente fallimento del trasferimento.
CAUSA – L’HD è formattato con file system FAT32 che prevede come limite della dimensione del file 4GB ben al di sotto del file trasferito.
SOLUZIONE – non ancora disponibile
APPROFONDIMENTI – A questo indirizzo è possibile trovare un confronto fra i file system maggiormente utilizzati.

]]> http://kuojenchiang.wordpress.com/2009/10/10/resizing-partition/ Sat, 10 Oct 2009 00:00:44 +0000 kuojenchiang http://kuojenchiang.wordpress.com/2009/10/10/resizing-partition/

still trying to figure out how to resize my home partition on this suse 10 on this hp mini 2140.

reading How To Resize ext3 Partitions Without Losing Data

next I should try to understand the unix file system by reading Getting to know the Solaris filesystem, Part 1

The FAT file system (FAT FS) enables the inserting developer from Zeeis to easily and integrates MS-DOS or the window compatible FAT file system using the nature mutually and all main operating system all equipment rapidly. It tested the use in several true time operating system and the canned food not to have RTOS. This high performance source code was the minimum memory consumption in RAM and ROM optimal, was cheap and is high speed.
In 2008, the Zeeis FAT file system product shipped the completely successful 25,000,000 equipment, is the leading filing system product for mobile, the electrical appliances and the storage application.

The .NET Framework doesn’t change the structure of the file system, nor does it build a new layer on top of it. More simply, but also more effectively for developers, it supplies a new object model for file system-related operations. A managed application can work with files and directories using high-level methods rather than low level understanding of the file system. This article provides an overview of methods and classes contained in the System.IO namespace.

The .NET Framework reworks, rationalizes, and simplifies key portions of the Win32 API, within the .NET Framework with very few exceptions… Microsoft has redesigned the whole Win32 API and made it available to programmers in an object-oriented fashion. In this article, you will see how to manage paths as a special data type with ad-hoc methods and properties; how to work to retrieve as much information as possible about files and directories, and how to read and write files.

Managing Files

The .NET Framework uses System.IO as the main namespace to work with file systems. Within this namespace, you can identify three groups of related classes that accomplish the following tasks:

• Retrieve information and perform basic operations on files and directories
• Perform string-based manipulation on paths
• Read and write operations on data streams and files

The .NET Framework provides I/O functionality through a few global static classes, such as File, Directory, and Path. You declare these classes as static (or shared in Visual Basic .NET) and in order to use them, you don’t need to create specific instances of the classes. File, Directory, and Path are just the repository of global, type-specific functions that you call to create, copy, delete, move, and open files and directories. All of these functions requires a file or a directory name to operate. To write or read files, you also have specific classes to manage streams and bytes at your disposal.

If you’re going to work with files within a .NET managed application, chances are good that you have to use the methods from the File class. So let’s start by taking a look at the methods exposed by this class (see Table 1).

The path parameter that all methods require can indicate a relative or absolute path. A relative path is interpreted as relative to the current working directory. To obtain the current working directory, you use the GetCurrentDirectory method provided by the Directory class. Any methods above that perform write operations that will create the specified file if it does not exist. If the file does exist, it will be overwritten as long as it is not marked read-only.

Each time an application invokes a method on the File class, a security check is performed on the involved file system elements. The check verifies that the current user has the permission to perform the specified operation. If you use the same file or directory several times, this embedded security check might result in a slight performance hit. For this and other reasons, the .NET Framework defines an instance-specific type to wrap the functionality of files called the FileInfo class. If you need to access a file in a repeated fashion, you can use the FileInfo class to perform the security check only once. Should you always use FileInfo and disregard the File class? Well, consider that, in general, the methods of the global classes have an internal implementation that results in more direct code. For this reason, global objects are preferable for one-shot calls.

If you look at the overall set of functionality both provide, the FileInfo class looks very similar to the static File class. However, the internal implementation and the programming interface is slightly different. The FileInfo class works on a particular file and requires that you instantiate the class before you access its methods and properties.

FileInfo fi = new FileInfo(“mydoc.txt”);

When you create an instance of the FileInfo class, you specify a filename, either fully or partially qualified. The filename you indicate is only checked for the name consistency and not for existence. If the filename you indicate through the class constructor is unacceptable an exception is thrown. Common pitfalls are colons in the middle of the string, invalid characters, blank names, or names longer than 256 characters. Table 2 lists the properties of the FileInfo class.

The methods available for the FileInfo class are summarized in Table 3. As you can see, you can group methods into two categories: methods to perform simple stream-based operations on the contents of the file, and methods to copy or delete the file itself.

The FileInfo class represents a logical wrapper for a system element that is continuously subject to concurrent changes. Can you be sure that the information returned by the FileInfo object is always up to date? Properties such as Exists, Length, Attributes, and LastAccessTime can easily contain inconsistent values if other users may make changes concurrently.

When you create an instance of FileInfo, no information is actually read from the file system. As soon as you attempt to read the value of one of the aforementioned critical properties, the class invokes the Refresh method, reads the current state of the file, and caches that information. For performance reasons, though, the FileInfo class doesn’t automatically refresh the state of the object each time properties are read. It does that only the first time that it reads one of the properties.

To force this built-in behavior, you should call Refresh whenever you need to read up-to-date information about the attributes or the length of a file. Whether or not you need to refresh this data depends greatly on the needs of your application. Under the hood, the Refresh method makes a call to the Win32 FindFirstFile function and uses the information contained in the returned WIN32_FIND_DATA structure to populate the properties of the FileInfo class. You need to consider whether or not the application needs the overhead of calling this API function.          

Copying and Deleting Files

To make a copy of the current file, you can use the CopyTo method, which comes with two overloads. Both overloads copy the file to another file but the first overload just disallows overwriting, while the other gives you a chance to control overwriting through a Boolean parameter.

FileInfo fi = fi.CopyTo(“NewFile.txt”, true);

Notice that both methods require that the first argument be a filename. It can’t be the name of a directory where you want the file to be copied. If you use a directory name, that will be the name of the output file.

The Delete method permanently deletes the file from disk. Using this method, there is no way to programmatically send the deleted file to the recycle bin. To put a file in the recycle bin you must resort to creating a .NET wrapper for the Win32 API function that does that. The API function you need is named SHFileOperation.

The Attributes property indicates the file system attributes of the given file. In order to set or read an attribute, the file must already exist and the application must have access to it. To write an attribute value to a file, you must also have a write permission, otherwise the FileIOPermissionAccess exception is raised. The attributes of a file are expressed using the FileAttributes type. (See Table 4.)

The values in the table correspond to those defined in the Win32 SDK. Notice that not all attributes are applicable to both files and directories. You set attributes on a file using code as in the code snippet below.

// Make the file read-only and hidden
FileInfo fi = new FileInfo(“mydoc.txt”)
fi.Attributes = FileAttributes.ReadOnly | 
                FileAttributes.Hidden;

Note you cannot set all of the attributes listed in Table 4 through the Attributes property. For example, the system assigns the Encrypted and the Compressed attributes only if the file is contained in an encrypted or compressed folder. Likewise, you can give a file a reparse point or you can mark is as a sparse file only through specific API functions and only on NTFS volumes.

Working with Directories

To manage a directory as an object you use the Directory global object or the DirectoryInfo class. The global Directory class exposes static methods for creating, copying, and moving directories and for enumerating their files and subdirectories. Table 5 lists the methods on the Directory class.

Note that the Delete method has two overloads. By default, it deletes only empty directories and throws an IOException exception if the directory is not empty or marked read-only. The second overload includes a Boolean argument that, if set to true, enables the method to recursively delete the entire directory tree.

// Clear a directory tree
Directory.Delete(dirName, true);

The DirectoryInfo class represents the instance-based counterpart of the Directory class and works on a particular directory.

DirectoryInfo di = new DirectoryInfo(@”c:\”);

To create an instance of the DirectoryInfo class, you specify a fully qualified path. Just as for FileInfo, the path is checked for consistency but not for existence. Note that the path can also be a filename or a Universal Naming Convention (UNC) name. If you create a DirectoryInfo object passing a filename, the class will use the directory that contains the specified file. Table 6 shows the properties available with the DirectoryInfo class.

The Name property of the file and directory classes is read-only and you cannot use it to rename the corresponding file system’s element. The methods you can use on the DirectoryInfo class are listed in Table 7.

The GetFileSystemInfos method returns an array of objects, each of which points to a file or a subdirectory contained in the directory bound to the current DirectoryInfo object. Unlike GetDirectories and GetFiles methods which simply return the names of subdirectories and files as plain strings, GetFileSystemInfos returns a strongly-typed object for each entry?either DirectoryInfo or FileInfo. The return type of the method is an array of FileSystemInfo objects.

public FileSystemInfo[] GetFileSystemInfos()

FileSystemInfo is the base class for both FileInfo and DirectoryInfo. GetFileSystemInfos has an overloaded version that can accept a string with search criteria.

Let’s see how to use the file and directory classes to build a simple console application that lists the contents of a directory. The full source code is presented in Listing 1.

GetFileSystemInfos accepts a filter string that you can use to set some criteria. The filter string can contain wild card characters such as ? and *. The ? character is a placeholder for any individual character, while * represents any string of one or more characters. A bit more problematic is selecting all files that belong to one group or another. Likewise, there’s no direct way to obtain all directories plus all the files that match certain criteria. In similar cases, you must query each result set individually and then combine them together in a single array of FileSystemInfo objects. The following code snippet shows how to select all the subdirectories and all the aspx pages in a given folder.

FileSystemInfo fsiDirs = (FileSystemInfo[]) 
        di.GetSubdirectories();
FileSystemInfo fsiAspx = (FileSystemInfo[]) 
        di.GetFiles(“.aspx”);

You can fuse the two arrays together using the methods of the Array class.

Working with Paths

Although paths are nothing more than strings, it’s a common feeling that they deserve a tailor-made set of functions to makes paths easier to manipulate. The Path type provides programmers with the unprecedented ability to perform operations on instances of a string class that contain file or directory path information. Path is a single-instance class that contains only static methods. A path can contain either absolute or relative location information for a given file or folder. If the information about the location is incomplete and partial, then the class completes it using the current location, if applicable.

The members of the Path class let you perform everyday operations such as: determining whether a given filename has a certain extension, changing the extension of a filename leaving all the remainder of the path intact, combining partial path strings into one valid path, and more. The Path class doesn’t work in conjunction with the operating system and should be simply viewed as a highly specialized string manipulation class.

The members of the Path class never interact with the file system to verify the correctness of a filename. Even though you can combine two strings to get a valid directory name, that would not be sufficient to actually create that new directory. On the other hand, the members of the Path class are smart enough to throw an exception if they detect that a path string contains invalid characters. Table 8 lists the methods of the Path class.

It’s interesting to notice that any call to GetTempFileName promptly results in creating a zero-length file on disk and specifically in the system’s temporary folder (i.e., C:\Windows\Temp). This is the only case in which the Path class happens to interact with the operating system.

I/O with Files

In the .NET Framework, the atomic element to read from, or write to, is the stream. A stream abstracts the contents of a variety of potential data stores, including local and network disk files, memory, and databases. You can read or write a Stream object using a couple of tailor-made tools?the reader and the writer.

A reader reads one chunk of information at a time. The structure of the data read depends on the particular reader and the underlying stream. For example, a text reader will read rows of text recognizing the carriage return/linefeed pair as the separator between chunks. Likewise, the binary reader will process every single byte in the stream as the XML reader moves from one node to the next. The reader operates in a read-only, forward-only way. You can’t move back to an already processed, or skipped, chunk of data; nor can you edit the current data the pointer references.

In the .NET Framework, you find available quite a few specialized readers including TextReader, BinaryReader, XmlReader, and database-specific readers such as SqlDataReader and OracleDataReader. Although all of these reader classes have a common subset of functions, and an overall similar way of working, they don’t derive from the same base class. Reader classes work on top of streams. Depending on the implementation of each individual class, the stream may be passed explicitly as a constructor argument or through its file name or URL.

The Stream class supports three basic operations: reading, writing, and seeking. Reading and writing operations entail transferring data from a stream into a data structure and vice versa. Seeking consists of querying and modifying the current position within the stream of data.

The .NET Framework provides a number of predefined Stream classes including FileStream, MemoryStream, and the fairly interesting CryptoStream, which automatically encrypts and decrypts data as you write or read. Each different storage implements its own stream by deriving from the base Stream class. The StreamReader class is a generic reader class for any type of stream. Finally, the StringReader class lets you read a string of text using the same programming interface as readers that operate on data stores.

You transform the contents of a file into a stream using the FileStream class. The following code shows how to open a file that you want to read:

FileStream fs = new FileStream(filename, 
FileMode.Open, FileAccess.Read);

Streams supply a rather low-level programming interface which, although functionally effective, is not always apt for classes that need to perform more high-level operations such as reading the whole content of a file or a single line.

To manipulate the contents of a file as a binary stream, you just pass the FileStream object down to a specialized reader object that knows how to handle it.

BinaryReader bin = new BinaryReader(fs);

If you want to process the file’s contents in a text-based way, then you can use the StreamReader class, as shown below.

StreamReader reader;
reader = new StreamReader(fileName);
reader.BaseStream.Seek(0, SeekOrigin.Begin);
string text = reader.ReadToEnd();
reader.Close();

To write files, you often use the StreamWriter class and access its underlying stream, which can also be an encrypted stream. The following code snippet shows how to create a file.

StreamWriter writer = new StreamWriter(file);
writer.WriteLine(text);
writer.Close();

Creating binary files that contain images or raw data doesn’t happen along different guidelines. You just use BinaryWriter (or BinaryReader for reading) as the writer object and its ad hoc set of methods.

All reader classes have a writer counter class. So you have a StreamWriter class acting as a generic writer for streams and more specific classes such as TextWriter, XmlWriter, BinaryWriter, and StringWriter. Curiously, the .NET Framework does not have a sort of SqlDataWriter class which would configure a server cursor. Server cursors are not supported as of version 1.1 of the .NET Framework.

Summary

Although the substance of the underlying file system is not something that changed with .NET, the platform that determines the way in which you work with the constituent elements of a file system?files and directories, changed quite a bit.

The introduction of streams as programmable objects is a key step in the sense that it unifies the API necessary to perform similar operations on conceptually similar storage media. Another key enhancement is the introduction of reader and writer objects. They provide a kind of logical API by means of which you read and write any piece of information in nearly identical ways. The .NET Framework also provides a lot of facilities to perform the basic management operations with files and directories, including path functions and common-use methods. In just one slogan, with .NET way of working with the file system is easier and more effective. Just do it

Ketika hendak melakukan format pada flash drive di Windows 7 beberapa hari yang lalu, saya melihat pilihan file system yang berbeda. Selain FAT, FAT32, dan NTFS, ada juga pilihan exFAT. Apa sih exFAT itu?

exFAT adalah file system besutan Microsoft yang dioptimasi untuk flash drive. Awalnya diperkenalkan untuk Windows CE 6.0, kemudian Windows Vista SP1, Windows XP SP2, dan Windows 7. Untuk Linux, modul kernel yang bersifat open source masih dalam tahap eksperimental, namun sudah ada driver exFAT yang sifatnya closed source.

exFAT umumnya digunakan ketika penggunaan NTFS tidak dimungkinkan, namun versi lama dari FAT tidak mencukupi.

Fitur-fitur exFAT antara lain:

• Ukuran file dapat mencapai 127 PiB (Pebibyte) atau sekitar 133 169 152 GB. Bandingkan dengan FAT32 yang hanya 4 GB minus satu byte, NTFS yang hingga 16 EiB (Exbibyte).
• Satu direktori dapat menampung 2 796 202 file.
• Satu partisi exFAT dapat berukuran hingga 64 ZiB (Zebibyte). Pada FAT32 hanya 2 TB.
• Nama file maksimum 255 karakter.

Namun exFAT juga tentunya memiliki beberapa kekurangan, antara lain:

• Memerlukan Service Pack 2 untuk dapat digunakan pada Windows XP dan 2003 (server) atau Service Pack 1 untuk Windows Vista.
• Tidak dapat digunakan pada Windows 2000, Me, atau yang lebih lama, serta pada kebanyakan sistem operasi non-Microsoft.
• Storage dengan format exFAT tidak dapat digunakan untuk ReadyBoost pada Windows Vista, meskipun dapat digunakan pada Windows 7, bahkan lebih leluasa karena batasan ukuran file jauh lebih besar.
• Microsoft belum merilis spesifikasi resmi exFAT.

Ketika hendak melakukan format pada flash drive (yang benar flash drive, bukan flash disk. Disk: something with a round shape resembling a flat circular plate) di Windows 7 beberapa hari yang lalu, saya melihat pilihan file system yang berbeda. Selain FAT, FAT32, dan NTFS, ada juga pilihan exFAT. Apa sih exFAT itu?

exFAT adalah file system besutan Microsoft yang dioptimasi untuk flash drive. Awalnya diperkenalkan untuk Windows CE 6.0, kemudian Windows Vista SP1, Windows XP SP2, dan Windows 7. Untuk Linux, modul kernel yang bersifat open source masih dalam tahap eksperimental, namun sudah ada driver exFAT yang sifatnya closed source.

exFAT umumnya digunakan ketika penggunaan NTFS tidak dimungkinkan, namun versi lama dari FAT tidak mencukupi.

Fitur-fitur exFAT antara lain:

• Ukuran file dapat mencapai 127 PiB (Pebibyte) atau sekitar 133 169 152 GB. Bandingkan dengan FAT32 yang hanya 4 GB minus satu byte, NTFS yang hingga 16 EiB (Exbibyte).
• Satu direktori dapat menampung 2 796 202 file.
• Satu partisi exFAT dapat berukuran hingga 64 ZiB (Zebibyte). Pada FAT32 hanya 2 TB.
• Nama file maksimum 255 karakter.

Namun exFAT juga tentunya memiliki beberapa kekurangan, antara lain:

• Memerlukan Service Pack 2 untuk dapat digunakan pada Windows XP dan 2003 (server) atau Service Pack 1 untuk Windows Vista.
• Tidak dapat digunakan pada Windows 2000, Me, atau yang lebih lama, serta pada kebanyakan sistem operasi non-Microsoft.
• Storage dengan format exFAT tidak dapat digunakan untuk ReadyBoost pada Windows Vista, meskipun dapat digunakan pada Windows 7, bahkan lebih leluasa karena batasan ukuran file jauh lebih besar.
• Microsoft belum merilis spesifikasi resmi exFAT.

Well sorry it has taken so long but here is the third installation in the series on the Linux file system. In case you haven’t been following before now, here are the links to part1 and part2.

In this portion I will discuss the following directories/partitions: /lost+found /lib /mnt and /tmp.

/lost+found

So you are working and all of a sudden there is a power outage. Or even worse your system suddenly crashes for no reason. Well the next time you boot up your machine Linux will try to recover any lost data/files. The result of this recovery attempt will be saved here. Sure the files in here might not make much sense but there is a small chance that there might be something that you might be able to actually use. Finally, for those of you that really want to know, this recovery is done by using the fsck command. Look into it yourself, since this isn’t the place to go into depth on it.

/lib

The location of all the shared library files. Think DLL files on Windows.

/mnt

This is the generic place to mount other file systems. Such as internal/external hard drives, CD-ROMS, DVD, and floppy disk if people still use those. For more information on mounting see the link to the post dedicated to this topic.  But I should mention that you can make any location a mount point, but it’s usually a good idea to have them all relatively “close” to each other.  Plus try not to overdo it, because really 50 different mount points might just be a little excessive.

/tmp

Temporary files are stored here. In other words, DON’T SAVE IMPORTANT STUFF HERE! This directory is cleared upon each reboot of the system. As a side note, this is really useful for getting around disk quotas. Just save your files here and then when you restart they will be gone. All you have to do is make sure that you won’t be needing those files ever again.

This is a continuation from part 1, so you might want to read that first in order to get a general idea of what’s going on.  That is  of course you are a somewhat experienced Linux user.

In this part of the series I will be discussing the following directories/partitions: /bin /boot /dev /etc /home.

/home

I will start by discussing the partition that is most familiar to most new users, /home.  First you should know that Linux, unlike Windows, was originally designed to be a multi-user system.  Thus in the home directory you will find a set of directories, one for each user.  Every user (along with the system administrator) can access their directory by entering cd /home/[user name].  Each user’s home directory contains their own personal files in addition to their personal settings for programs.

/bin

This directory contains programs that are able to be used by the system(Linux), the administrator and non-privileged users. Examples of such programs would include cp, mv, rm, and other such commands/programs. In addition to programs it also contains the shells, like bash, csh, sh, and so on. Just as a side note, you should be aware that there is also a /usr/bin which also contains programs that the system, administrator, and non-privileged users can use. However, unlike those in /bin, these programs are not essential-meaning that you can do without them and not have any real problems. Some programs that are located in my /usr/bin are: g++, apt-get, javac, whoami, and acroread. Sure it would be a pain not having these programs, but the system would still run perfectly fine.

/boot

All of the system startup files and the kernel (vmlinuz) are located in this directory (also I would suggest reading the Wikipedia article on System.map, which is also stored in this directory). On Ubuntu, this is also where Grub (GRand Unified Boot loader) stored.  For those of you that are dual-booting here is something that might interest you.  When you start up your system you will normally see a list asking you which OS you want to enter.  This list normally contains the various Linux kernels along with Windows (or whatever OS you have on your computer).  If you would like to change the order these elements are presented along with other properties here is what you need to do.  cd /boot/grub then sudo gedit menu.lst (actually you can use whatever text editor you desire)  The file is pretty well documented so editing it is pretty straight forward.

/dev

All computers have hardware, and this is where the information on all your hardware is stored. Once again let me reiterate that EVERYTHING is a file (or directory but I don’t distinguish between them in this case). If you list all of the files here, you should find sda, sda1, sda2… which represent the partitions of you master drive (instead of sda you might have hda depending on your drive type). Also you might see a files /dev/cdrom and /dev/fd or (/dev/fd0). These represent your CDROM and floppy drive (if you have them that is, because really who still has a floppy drive?). Here is something “cool” that you should all try (don’t worry it won’t damage your computer. I have done it on mine if that makes you feel any better). The file /dev/dsp represents your speakers (or whatever sound output device you have). So anything written to this file will be redirected to your speakers and played for you to hear. Thus if you run cat ~/funfile.java > /dev/dsp you will hear what funfile.java “sounds like”, assuming that you have a file called funfile.java in your home directory. Pretty cool hu?

/etc

Finally, I will slightly discuss the /etc directory.  One overview that I read, described this directory as the Linux equivalent to the Control Panel in Windows.  Basically most of the important configuration files are located here.  There are a lot of important files here that have to do with system start up (one being /etc/rc.d which contains the startup scripts for the system). It is always a good idea to back up your system, but this file more than any other I would say should really be backed up. Doing so would save you a lot of headache later when you have to reconfigure your settings, because you reinstalled your system or somehow managed to lose your installation.

Well that’s all there is for part 2. Hope you will stick around for part 3.

The Gestalt IT Field Day was a great success in bringing together a mixture of delegates from varying discplines. Following the presentations from 3Par and Symantec, there was heated debate about the implementation of Thin Provisioning and the ability to reclaim released storage resources. This post covers the basic concepts of Thin Provisioning and more importantly how deleted resources can be recovered over time.

Thin Provisioning Primer

The underlying concept of thin provisioning is pretty simple; provide storage resources to those requesting it only as they need it.

Think of a standard ‘thick provisioned’ environment.  As thick LUNs are created, the storage is assigned and mapped to that LUN to the full extent of the size requested.  See, the first graphic, which shows a RAID group of four 5GB drives.  I’ve assumed “RAID-0″ here for simplification, i.e. no RAID overhead.  Each LUN (coloured separately) is made up from a 1GB slice of the available disks.  Thick provisioning is great if the LUNs are all 100% allocated.  In that instance, 100% of the available physical space is used up.  However, it is never the case that 100% of a LUN is used and so wastage exists. 

Look at the second graphic.  This shows how thin provisioned LUNs work.  As storage is requested by the LUN, the space is mapped to physical blocks of storage.  In this example, none of the logical LUNs are fully utilised and so don’t consume their full theoretical capacity.  This means that the pool of space can be over-subscribed and a sixth new LUN created.  Obviously there’s no such thing as a free lunch or infinite storage resources and in this example if a further five blocks are requested then physical space would be exhausted.  The next request for a new storage block would result in an error situation and this represents the main concern with over-subscribing thin provisioned volumes.

Now we get the concept of thin provisioning, there are a further two aspects to consider.  Firstly, when we say a LUN isn’t 100% utilised, what to we mean?  Second, how can deleted blocks be returned to our free physical pool?

As LUNs are presented to hosts, they are formatted with a file system, for example on Windows it’s NTFS; a VMware environment would use VMFS.  The file system will have a standard layout which determines where the file index sits and the method in which files are allocated onto the disk.  Have a look at the third graphic.  This is a map of the C:\ drive for one of my servers.  Each block represents approximately 22MB.  You can clearly see the MFT (NTFS index) in the centre of the volume.  A large percentage of the disk is unused.  In a thin provisioned environment, storage would have been requested only for the blocks with valid data and in this way, a LUN can be less than 100% allocated. 

OK, so what happens if I create some files then delete them on the file system?  Most file systems remove a file by deleting the entry in the index rather than physically overwriting the file contents with binary zeros.  This is quick and efficient (if not slightly unsafe security wise).  The actual data isn’t overwritten and it is this ‘logical’ deletion that enables undelete utilities to work.  The trouble is, most disk arrays are not file system aware and so can’t detect the logical deletion of a file.  Those arrays that offer thin provisioning typically detect unwanted space by looking for blocks containing only ‘binary zeros’.  This means simply deleting files will not release unused space back to the free block pool (except for one storage device I’ll discuss in more detail another time, that’s Drobo). Arrays which are capable of recovering unused space need to see data overwritten in order to recover it.

This (finally) brings us to the cookie analogy.  Imagine cookies are my free pool blocks.  There are a number of ways in which storage arrays operate in handling thin provisioning – different cookie monster personalities:

• The Greedy Cookie Monster; grabs all the cookies he thinks he might eat, but never eats all of them and never returns any – this is the thick provisioning model.
• The Selfish Cookie Monster; only grabs cookies as he gets hungry but if he doesn’t eat them immediately, doesn’t give them back – this is thin provisioning with no zero block reclaim.  Eventually thin provisioning will become thick as all logical blocks in a LUN become mapped to physical storage.
• The Nice Cookie Monster; takes the cookies as he gets hungry but only returns uneaten cookies if asked – this is thin provisioning with manual zero block reclaim.  A manual process is required to zero out the unused space and to return it to the free pool.
• The Saintly Cookie Monster; takes the cookes as he gest hungry and offers them back immediately he realises he can’t eat them  – this is thin provisioning with automatic zero block or free space reclaim. 

So, of the storage arrays out there offering thin provisioning, which fit the various Cookie Monster personality types?  I’ll leave that for you to guess.