Diff for /wikisrc/guide/rmmedia.mdwn between versions 1.5 and 1.7

version 1.5, 2015/06/19 19:18:31 version 1.7, 2021/04/12 13:15:03
Line 1 Line 1
 **Contents**  This page was moved to:
   [The NetBSD Guide - Using removable media](//www.NetBSD.org/docs/guide/en/chap-rmmedia.html)
 [[!toc levels=3]]  
 # Using removable media  
 ## Reading data CDs with NetBSD  
 Data CDs can contain anything from programs, sound files (MP3, wav), movies  
 (MP3, QuickTime) to source code, text files, etc. Before accessing these files,  
 a CD must be mounted on a directory, much like hard disks are. Just as hard  
 disks can use different filesystems (ffs, lfs, ext2fs, ...), CDs have their own  
 filesystem, *cd9660*. The NetBSD cd9660 filesystem can handle filesystems  
 without and with Rockridge and Joliet extensions.  
 CD devices are named /dev/cd0a for both SCSI and IDE (ATAPI).  
 With this information, we can start:  
  1. See if your system has some CD drive:  
         # dmesg | grep ^cd  
              cd0 at atapibus0 drive 0: <CD-R/RW RW8040A, , 1.12> type 5 cdrom removable  
              cd0: 32-bit data port  
              cd0: drive supports PIO mode 4, DMA mode 0  
              cd0(pciide0:1:0): using PIO mode 0, DMA mode 0 (using DMA data transfers)  
         We have one drive here, `cd0`. It is an IDE/ATAPI drive, as it is found on  
         atapibus0. Of course the drive (rather, its medium) is removable, i.e., you  
         can eject it. See below.  
  2. Insert a CD  
  3. Mount the CD manually:  
         # mount -t cd9660 /dev/cd0a /mnt  
         This command shouldn't print anything. It instructs the system to mount the  
         CD found on /dev/cd0a on /mnt, using the `cd9660` filesystem. The mountpoint  
         `/mnt` must be an existing directory.  
  4. Check the contents of the CD:  
         # ls /mnt  
         INSTALL.html INSTALL.ps   TRANS.TBL    boot.catalog  
         INSTALL.more INSTALL.txt  binary       installation  
     Everything looks fine! This is a NetBSD CD, of course. :)  
  5. Unmount the CD:  
         # umount /mnt  
         If the CD is still accessed (e.g. some other shell's still "cd"'d into it),  
         this will not work. If you shut down the system, the CD will be unmounted  
         automatically for you, there's nothing to worry about there.  
  6. Making an entry in /etc/fstab:  
         If you don't want to type the full "mount" command each time, you can put  
         most of the values into a line in /etc/fstab:  
         # Device        mountpoint      filesystem  mount options  
         /dev/cd0a       /cdrom          cd9660      ro,noauto      
         Make sure that the mountpoint, `/cdrom` in our example, exists:  
         # mkdir /cdrom  
         Now you can mount the cd with the following command:  
         # mount /cdrom  
     Access and unmount as before.  
         The CD is not mounted at boot time due to the "noauto" mount option - this  
         is useful as you'll probably not have a CD in the drive all the time. See  
         [[!template id=man name="mount" section="8"]]  
         [[!template id=man name="mount\_cd9660" section="8"]]  
         for some other useful options.  
 7.  Eject the CD:  
         # eject cd0  
         If the CD is still mounted, it will be unmounted if possible, before being  
 ## Reading multi-session CDs with NetBSD  
 [[!template id=man name="mscdlabel" section="8"]]  
 to add all sessions to the CDs disklabel, and then use the appropriate device  
 node to mount the session you want. You might have to create the corresponding  
 device nodes in `/dev` manually. For example:  
     # mscdlabel cd1  
     track (ctl=4) at sector 142312  
      adding as 'a'  
     track (ctl=4) at sector 0  
      adding as 'b'  
     # ls -l /dev/cd1b  
     ls: /dev/cd1b: No such file or directory  
     # cd /dev  
     # ls -l cd1*  
     brw-r-----  1 root  operator       6,  8 Mar 18 21:55 cd1a  
     brw-r-----  1 root  operator       6, 11 Mar 18 21:55 cd1d  
     # mknod cd1b b 6 9  
 to create `/dev/cd1b`. Make sure you fix the permissions of any new device nodes  
 you create:  
     # ls -l cd1*  
     brw-r-----  1 root  operator       6,  8 Mar 18 21:55 cd1a  
     brw-r--r--  1 root  wheel          6,  9 Mar 18 22:23 cd1b  
     brw-r-----  1 root  operator       6, 11 Mar 18 21:55 cd1d  
     # chgrp operator cd1b  
     # chmod 640 cd1b  
     # ls -l cd1*  
     brw-r-----  1 root  operator       6,  8 Mar 18 21:55 cd1a  
     brw-r-----  1 root  operator       6,  9 Mar 18 22:24 cd1b  
     brw-r-----  1 root  operator       6, 11 Mar 18 21:55 cd1d  
 Now you should be able to mount it.  
     # mount /dev/cd1b /mnt  
 ## Allowing normal users to access CDs  
 By default, NetBSD only allows "root" to mount a filesystem. If you want any  
 user to be able to do this, perform the following steps:  
  * Give groups and other the access rights to the device.  
         # chmod go+rw /dev/cd0a  
  * Ask NetBSD to let users mounting filesystems.  
         # sysctl -w vfs.generic.usermount=1  
         Note that this works for any filesystem and device, not only for CDs with a  
         ISO 9660 filesystem.  
 To perform the mount operation after these commands, the user must own the mount  
 point. So, for example:  
     $ cd $HOME  
     $ mkdir cdrom  
     $ mount -t cd9660 -o nodev,nosuid /dev/cd0a `pwd`/cdrom  
 *Note*: The mount options `nodev` and `nosuid` are mandatory from NetBSD 4.0 on.  
 They are not necessary on NetBSD 3.x systems.  
 Please also see  
 [[!template id=man name="mount" section="8"]] and  
 as an alternative the *auto mount daemon*  
 [[!template id=man name="amd" section="8"]], for  
 which example config files can be found in `/usr/share/examples/amd`.  
 ## Mounting an ISO image  
 Sometimes, it is interesting to mount an ISO9660 image file before you burn the  
 CD; this way, you can examine its contents or even copy files to the outside. If  
 you are a Linux user, you should know that this is done with the special *loop*  
 filesystem. NetBSD does it another way, using the *vnode* pseudo-disk.  
 We will illustrate how to do this with an example. Suppose you have an ISO image  
 in your home directory, called `mycd.iso`:  
  1. Start by setting up a new vnode, "pointing" to the ISO file:  
         # vnconfig -c vnd0 ~/mycd.iso  
  2. Now, mount the vnode:  
         # mount -t cd9660 /dev/vnd0a /mnt  
  3. Yeah, image contents appear under `/mnt`! Go to that directory and explore  
     the image.  
  4. When you are happy, you have to umount the image:  
         # umount /mnt  
  5. And at last, deconfigure the vnode:  
         # vnconfig -u vnd0  
 Note that these steps can also be used for any kind of file that contains a  
 filesystem, not just ISO images.  
 See the [[!template id=man name="vnd" section="4"]]  
 [[!template id=man name="vnconfig" section="8"]]  
 man pages for more information.  
 ## Using video CDs with NetBSD  
 To play MPEG Video streams as many DVD players can play them under NetBSD, mount  
 the CD as you would do with any normal (data) CD (see [[Reading data CDs with  
 NetBSD|guide/rmmedia#cdrom]]), then use the  
 package to play the mpeg files stored on the CD.  
 ## Using audio CDs with NetBSD  
 There are two ways to handle audio CDs:  
  1. Tell the CD drive to play to the headphone or to a soundcard, to which  
         CDROMs are usually connected internally. Use programs like  
         [[!template id=man name="cdplay" section="1"]],  
         "kscd" from the  
         package, mixer programs like  
         [[!template id=man name="mixerctl" section="1"]],  
         the Curses based  
         or kmix, which is part of  
         This usually works well on both SCSI and IDE (ATAPI) CDROMs, CDRW and DVD  
  2. To read ("rip") audio tracks in binary form without going through  
         digital-\>analog conversion and back. There are several programs available  
         to do this:  
          * For most ATAPI, SCSI and several proprietary CDROM drives, the  
            package can be used. With cdparanoia the data can be saved to a file or  
            directed to standard output in WAV, AIFF, AIFF-C or raw format. Currently  
            the -g option is required by the NetBSD version of cdparanoia. A  
            hypothetical example of how to save track 2 as a WAV file is as follows:  
            $ cdparanoia -g /dev/rcd0d 2 track-02.wav  
        If you want to grab all files from a CD, cdparanoia's batch mode is useful:  
            $ cdparanoia -g /dev/rcd0d -B  
          * For ATAPI or SCSI CD-ROMs the  
            package can be used. To extract track 2 with cdd, type:  
            # cdd -t 2 `pwd`  
        This will put a file called `track-02.cda` in the current directory.  
          * For SCSI CD-ROMS the  
            package can be used. To extract track 2 with tosha, you should be able to  
            # tosha -d CD-ROM-device -t 2 -o track-02.cda  
         The data can then be post-processed e.g. by encoding it into MP3 streams  
         (see [[Creating an MP3 (MPEG layer 3) file from an audio  
         CD|guide/rmmedia#create-mpeg3]]) or by writing them to CD-Rs (see [[Using a  
         CD-R writer to create audio CDs|guide/rmmedia#cdr-audio]]).  
 ## Creating an MP3 (MPEG layer 3) file from an audio CD  
 The basic steps in creating an MPEG layer 3 (MP3) file from an audio CD (using  
 software from the [NetBSD packages  
 collection](http://www.NetBSD.org/docs/pkgsrc/)) are:  
  1. Extract (*rip*) the audio data of the CD as shown in  
     [[Using audio CDs with NetBSD|guide/rmmedia#cdrom-audio]].  
  2. Convert the CD audio format file to WAV format. You only need to perform  
         this job if your ripping program (e.g. tosha, cdd) didn't already do the job  
         for you!  
      * Using the [`audio/sox`](http://ftp.NetBSD.org/pub/pkgsrc/current/pkgsrc/audio/sox/README.html) package, type:  
            $ sox -s -w -c 2 -r 44100 -t cdr track-02.cda track-02.wav  
            This will convert `track-02.cda` in raw CD format to `track-02.wav` in  
            WAV format, using **s**igned 16-bit **w**ords with 2 **c**hannels at a  
            sampling **r**ate of 44100kHz.  
  3. Encode the WAV file into MP3 format.  
      * Using the [`audio/bladeenc`](http://ftp.NetBSD.org/pub/pkgsrc/current/pkgsrc/audio/bladeenc/README.html) package, type:  
            $ bladeenc -128 -QUIT track-02.wav  
            This will encode `track-02.wav` into `track-02.mp3` in MP3 format, using  
            a bit rate if **128**kBit/sec. The documentation for bladeenc describes  
            bit-rates in more detail.  
          * Using the  
            package, type:  
            $ lame -p -o -v -V 5 -h track-02.wav track-02.mp3  
            You may wish to use a lower quality, depending on your taste and  
 The resultant MP3 file can be played with any of the  
 ## Using a CD-R writer with data CDs  
 The process of writing a CD consists of two steps: First, a "image" of the data  
 must be generated, which can then be written to CD-R in a second step.  
  1. Reading a pre-existing ISO image  
         # dd if=/dev/rcd0a of=filename.iso bs=2k  
     Alternatively, you can create a new ISO image yourself:  
  2. 2. 2.ating the ISO image  
         Put all the data you want to put on CD into one directory. Next you need to  
         generate a disk-like ISO image of your data. The image stores the data in  
         the same form as they're later put on CD, using the ISO 9660 format. The  
         basic ISO9660 format only understands 8+3 filenames (max. eight letters for  
         filename, plus three more for an extension). As this is not practical for  
         Unix filenames, a so-called "Rockridge Extension" needs to be employed to  
         get longer filenames. (A different set of such extension exists in the  
         Microsoft world, to get their long filenames right; that's what's known as  
         Joliet filesystem).  
         The ISO image is created using the mkisofs command, which is part of the  
         Example: if you have your data in /usr/tmp/data, you can generate a ISO  
         image file in /usr/tmp/data.iso with the following command:  
         $ cd /usr/tmp  
         $ mkisofs -o data.iso -r data  
         Using NETBS000.GZ;1 for  data/binary/kernel/netbsd.INSTALL.gz (netbsd.INSTALL_TINY.gz)  
         Using NETBS001.GZ;1 for  data/binary/kernel/netbsd.GENERIC.gz (netbsd.GENERIC_TINY.gz)  
           5.92% done, estimate finish Wed Sep 13 21:28:11 2000  
          11.83% done, estimate finish Wed Sep 13 21:28:03 2000  
          17.74% done, estimate finish Wed Sep 13 21:28:00 2000  
          23.64% done, estimate finish Wed Sep 13 21:28:03 2000  
          88.64% done, estimate finish Wed Sep 13 21:27:55 2000  
          94.53% done, estimate finish Wed Sep 13 21:27:55 2000  
         Total translation table size: 0  
         Total rockridge attributes bytes: 5395  
         Total directory bytes: 16384  
         Path table size(bytes): 110  
         Max brk space used 153c4  
         84625 extents written (165 Mb)  
         Please see the mkisofs(8) man page for other options like noting publisher  
         and preparer. The [Bootable CD ROM  
         How-To](http://www.NetBSD.org/docs/bootcd.html) explains how to generate a  
         bootable CD.  
  3. Writing the ISO image to CD-R  
         When you have the ISO image file, you just need to write it on a CD. This is  
         done with the "cdrecord" command from the  
         package. Insert a blank CD-R, and off we go:  
         # cdrecord -v dev=/dev/rcd0d data.iso  
         After starting the command, 'cdrecord' shows you a lot of information about  
         your drive, the disk and the image you're about to write. It then does a 10  
         seconds countdown, which is your last chance to stop things - type \^C if  
         you want to abort. If you don't abort, the process will write the whole  
         image to the CD and return with a shell prompt.  
         Note that cdrecord(8) works on both SCSI and IDE (ATAPI) drives.  
  4. Test  
         Mount the just-written CD and test it as you would do with any "normal" CD,  
         see [[Reading data CDs with NetBSD|guide/rmmedia#cdrom]].  
 ## Using a CD-R writer to create audio CDs  
 If you want to make a backup copy of one of your audio CDs, you can do so by  
 extracting ("ripping") the audio tracks from the CD, and then writing them back  
 to a blank CD. Of course this also works fine if you only extract single tracks  
 from various CDs, creating your very own mix CD!  
 The steps involved are:  
  1. Extract ("rip") the audio tracks as described as in  
     [[Using audio CDs with NetBSD|guide/rmmedia#cdrom-audio]]  
         to get a couple of .wav files.  
  2. Write the .wav files using cdrecord command from the  
         # cdrecord -v dev=/dev/rcd0d -audio -pad *.wav  
 ## Creating an audio CD from MP3s  
 If you have converted all your audio CDs to MP3 and now want to make a mixed CD  
 for your (e.g.) your car, you can do so by first converting the .mp3 files back  
 to .wav format, then write them as a normal audio CD.  
 The steps involved here are:  
  1. Create .wav files from your .mp3 files:  
         $ mpg123 -w foo.wav foo.mp3  
         Do this for all of the MP3 files that you want to have on your audio CD. The  
         .wav filenames you use don't matter.  
  2. Write the .wav files to CD as described under [[Using a CD-R writer to  
     create audio CDs|guide/rmmedia#cdr-audio]].  
 ## Copying an audio CD  
 To copy an audio CD while not introducing any pauses as mandated by the CDDA  
 standard, you can use cdrdao for that:  
     # cdrdao read-cd --device /dev/rcd0d data.toc  
     # cdrdao write   --device /dev/rcd1d data.toc  
 ## Copying a data CD with two drives  
 If you have both a CD-R and a CD-ROM drive in your machine, you can copy a data  
 CD with the following command:  
     # cdrecord dev=/dev/rcd1d /dev/rcd0d  
 Here the CD-ROM (cd0) contains the CD you want to copy, and the CD-R (cd1)  
 contains the blank disk. Note that this only works with computer disks that  
 contain some sort of data, it does *not* work with audio CDs! In practice you'll  
 also want to add something like `speed=8` to make things a bit faster.  
 ## Using CD-RW rewritables  
 You can treat a CD-RW drive like a CD-R drive (see [[Using a CD-R writer with  
 data CDs|guide/rmmedia#cdr]]) in NetBSD, creating images with mkisofs(8) and  
 writing them on a CD-RW medium with cdrecord(8).  
 If you want to blank a CD-RW, you can do this with cdrecord's `blank` option:  
     # cdrecord dev=/dev/rcd0d blank=fast  
 There are several other ways to blank the CD-RW, call cdrecord(8) with  
 `blank=help` for a list. See the cdrecord(8) man page for more information.  
 ## DVD support  
 Currently, NetBSD supports DVD media through the ISO 9660 also used for CD-ROMs.  
 The new UDF filesystem also present on DVDs has been supported since NetBSD 4.0.  
 Information about mounting ISO 9660 and UDF filesystems can be found in the  
 [[!template id=man name="mount\_cd9660" section="8"]]  
 [[!template id=man name="mount\_udf" section="8"]]  
 manual pages respectively. DVDs, DivX and many avi files be played with  
 For some hints on creating DVDs, see this [postings about  
 growisofs](http://mail-index.NetBSD.org/current-users/2004/01/06/0021.html) and  
 [this article about recording CDs and DVDs with  
 ## Creating ISO images from a CD  
 To create an ISO image and save the checksum do this:  
     # readcd dev=/dev/cd0d f=/tmp/cd.iso  
 Here is an alternative using dd(1):  
     # dd if=/dev/cd0d of=/tmp/cd.iso bs=2048  
 If the CD has errors you can recover the rest with this:  
     # dd if=/dev/cd0d of=/tmp/cd.iso bs=2048 conv=noerror  
 To create an ISO image from a mounted data CD first, mount the CD disk by:  
     # mount -t cd9660 -r /dev/cd0d /mnt/cdrom  
 Second, get the image:  
     # mkhybrid -v -l -J -R -o /tmp/my_cd.iso /mnt/cdrom/  
 ## Getting volume information from CDs and ISO images  
 You can read the volume data from an unmounted CD with this command:  
     # file -s /dev/cd0d  
 You can read the volume data from an ISO image with this command:  
     # isoinfo -d -i /tmp/my_cd.iso  
 You can get the unique disk number from an unmounted CD with this:  
     # cd-discid /dev/cd0d  
 You can read the table of contents of an unmounted CD with this command:  
     # cdrecord -v dev=/dev/cd0d -toc  
 ## Initializing and using floppy disks  
 PC-style floppy disks work mostly like other disk devices like hard disks,  
 except that you need to low-level format them first. To use an common 1440 KB  
 floppy in the first floppy drive, first (as root) format it:  
     # fdformat -f /dev/rfd0a  
 Then create a single partition on the disk using  
 [[!template id=man name="disklabel" section="8"]]:  
     # disklabel -rw /dev/rfd0a floppy3  
 Creating a small filesystem optimized for space:  
     # newfs -m 0 -o space -i 16384 -c 80 /dev/rfd0a  
 Now the floppy disk can be mounted like any other disk. Or if you already have a  
 floppy disk with an MS-DOS filesystem on it that you just want to access from  
 NetBSD, you can just do something like this:  
     # mount -t msdos /dev/fd0a /mnt  
 However, rather than using floppies like normal (bigger) disks, it is often more  
 convenient to bypass the filesystem altogether and just splat an archive of  
 files directly to the raw device. E.g.:  
     # tar cvfz /dev/rfd0a file1 file2 ...  
 A variation of this can also be done with MS-DOS floppies using the  
 package which has the benefit of not going through the kernel buffer cache and  
 thus not being exposed to the danger of the floppy being removed while a  
 filesystem is mounted on it.  

Removed from v.1.5  
changed lines
  Added in v.1.7

CVSweb for NetBSD wikisrc <wikimaster@NetBSD.org> software: FreeBSD-CVSweb