← Documents Documentation/cdrom/cdrom-standard.rst GitHub 원문 ↗

Linux 6.18.37 · CD-ROM

A Linux CD-ROM standard

Linux Uniform CD-ROM Driver가 low-level driver의 capability와 behavior를 분리하고 open·ioctl·media 상태를 일관되게 제공하는 interface와 migration 절차를 설명합니다.

Source pathDocumentation/cdrom/cdrom-standard.rst
Source versionLinux v6.18.37
TranslationDUJINLABS 전문 번역 + 해설

요약·해설과 원문, 전문 번역을 서로 분리했습니다. API 이름, symbol, source path는 원문 표기를 사용합니다.

1. 요약·해설

원문의 핵심 논리와 kernel programming 관점의 보충 설명입니다. 아래의 전문 번역과는 별도로 작성했습니다.

요약과 해설

cdrom-standard.rst:1-1047

이 역사적 문서는 driver마다 달랐던 CD-ROM `open()`과 `ioctl()` 동작을 `cdrom.c`의 Uniform CD-ROM Driver layer로 통일하는 설계를 설명합니다.

`cdrom_device_ops`는 low-level driver가 제공하는 mechanism과 capability를, `cdrom_device_info`는 개별 drive의 property·mask·behavior option을 나타냅니다. 공통 layer는 user memory 검증, address format 변환, use count와 open/release 정책을 맡습니다.

특히 `O_NONBLOCK`으로 control-only audio open과 검증이 필요한 data open을 구분하고, 기존·audio·신규·device-dependent ioctl의 처리 경로와 기존 driver를 새 interface로 옮기는 절차를 규정합니다.

2. 영어 원문 전체

번역 기준이 된 Linux v6.18.37 원문입니다. 줄 번호는 이 버전의 파일 좌표입니다.

원문 전체 펼치기
1 =======================
2 A Linux CD-ROM standard
3 =======================
4
5 :Author: David van Leeuwen <david@ElseWare.cistron.nl>
6 :Date: 12 March 1999
7 :Updated by: Erik Andersen (andersee@debian.org)
8 :Updated by: Jens Axboe (axboe@image.dk)
9
10
11 Introduction
12 ============
13
14 Linux is probably the Unix-like operating system that supports
15 the widest variety of hardware devices. The reasons for this are
16 presumably
17
18 - The large list of hardware devices available for the many platforms
19 that Linux now supports (i.e., i386-PCs, Sparc Suns, etc.)
20 - The open design of the operating system, such that anybody can write a
21 driver for Linux.
22 - There is plenty of source code around as examples of how to write a driver.
23
24 The openness of Linux, and the many different types of available
25 hardware has allowed Linux to support many different hardware devices.
26 Unfortunately, the very openness that has allowed Linux to support
27 all these different devices has also allowed the behavior of each
28 device driver to differ significantly from one device to another.
29 This divergence of behavior has been very significant for CD-ROM
30 devices; the way a particular drive reacts to a `standard` *ioctl()*
31 call varies greatly from one device driver to another. To avoid making
32 their drivers totally inconsistent, the writers of Linux CD-ROM
33 drivers generally created new device drivers by understanding, copying,
34 and then changing an existing one. Unfortunately, this practice did not
35 maintain uniform behavior across all the Linux CD-ROM drivers.
36
37 This document describes an effort to establish Uniform behavior across
38 all the different CD-ROM device drivers for Linux. This document also
39 defines the various *ioctl()'s*, and how the low-level CD-ROM device
40 drivers should implement them. Currently (as of the Linux 2.1.\ *x*
41 development kernels) several low-level CD-ROM device drivers, including
42 both IDE/ATAPI and SCSI, now use this Uniform interface.
43
44 When the CD-ROM was developed, the interface between the CD-ROM drive
45 and the computer was not specified in the standards. As a result, many
46 different CD-ROM interfaces were developed. Some of them had their
47 own proprietary design (Sony, Mitsumi, Panasonic, Philips), other
48 manufacturers adopted an existing electrical interface and changed
49 the functionality (CreativeLabs/SoundBlaster, Teac, Funai) or simply
50 adapted their drives to one or more of the already existing electrical
51 interfaces (Aztech, Sanyo, Funai, Vertos, Longshine, Optics Storage and
52 most of the `NoName` manufacturers). In cases where a new drive really
53 brought its own interface or used its own command set and flow control
54 scheme, either a separate driver had to be written, or an existing
55 driver had to be enhanced. History has delivered us CD-ROM support for
56 many of these different interfaces. Nowadays, almost all new CD-ROM
57 drives are either IDE/ATAPI or SCSI, and it is very unlikely that any
58 manufacturer will create a new interface. Even finding drives for the
59 old proprietary interfaces is getting difficult.
60
61 When (in the 1.3.70's) I looked at the existing software interface,
62 which was expressed through `cdrom.h`, it appeared to be a rather wild
63 set of commands and data formats [#f1]_. It seemed that many
64 features of the software interface had been added to accommodate the
65 capabilities of a particular drive, in an *ad hoc* manner. More
66 importantly, it appeared that the behavior of the `standard` commands
67 was different for most of the different drivers: e. g., some drivers
68 close the tray if an *open()* call occurs when the tray is open, while
69 others do not. Some drivers lock the door upon opening the device, to
70 prevent an incoherent file system, but others don't, to allow software
71 ejection. Undoubtedly, the capabilities of the different drives vary,
72 but even when two drives have the same capability their drivers'
73 behavior was usually different.
74
75 .. [#f1]
76 I cannot recollect what kernel version I looked at, then,
77 presumably 1.2.13 and 1.3.34 --- the latest kernel that I was
78 indirectly involved in.
79
80 I decided to start a discussion on how to make all the Linux CD-ROM
81 drivers behave more uniformly. I began by contacting the developers of
82 the many CD-ROM drivers found in the Linux kernel. Their reactions
83 encouraged me to write the Uniform CD-ROM Driver which this document is
84 intended to describe. The implementation of the Uniform CD-ROM Driver is
85 in the file `cdrom.c`. This driver is intended to be an additional software
86 layer that sits on top of the low-level device drivers for each CD-ROM drive.
87 By adding this additional layer, it is possible to have all the different
88 CD-ROM devices behave **exactly** the same (insofar as the underlying
89 hardware will allow).
90
91 The goal of the Uniform CD-ROM Driver is **not** to alienate driver developers
92 whohave not yet taken steps to support this effort. The goal of Uniform CD-ROM
93 Driver is simply to give people writing application programs for CD-ROM drives
94 **one** Linux CD-ROM interface with consistent behavior for all
95 CD-ROM devices. In addition, this also provides a consistent interface
96 between the low-level device driver code and the Linux kernel. Care
97 is taken that 100% compatibility exists with the data structures and
98 programmer's interface defined in `cdrom.h`. This guide was written to
99 help CD-ROM driver developers adapt their code to use the Uniform CD-ROM
100 Driver code defined in `cdrom.c`.
101
102 Personally, I think that the most important hardware interfaces are
103 the IDE/ATAPI drives and, of course, the SCSI drives, but as prices
104 of hardware drop continuously, it is also likely that people may have
105 more than one CD-ROM drive, possibly of mixed types. It is important
106 that these drives behave in the same way. In December 1994, one of the
107 cheapest CD-ROM drives was a Philips cm206, a double-speed proprietary
108 drive. In the months that I was busy writing a Linux driver for it,
109 proprietary drives became obsolete and IDE/ATAPI drives became the
110 standard. At the time of the last update to this document (November
111 1997) it is becoming difficult to even **find** anything less than a
112 16 speed CD-ROM drive, and 24 speed drives are common.
113
114 .. _cdrom_api:
115
116 Standardizing through another software level
117 ============================================
118
119 At the time this document was conceived, all drivers directly
120 implemented the CD-ROM *ioctl()* calls through their own routines. This
121 led to the danger of different drivers forgetting to do important things
122 like checking that the user was giving the driver valid data. More
123 importantly, this led to the divergence of behavior, which has already
124 been discussed.
125
126 For this reason, the Uniform CD-ROM Driver was created to enforce consistent
127 CD-ROM drive behavior, and to provide a common set of services to the various
128 low-level CD-ROM device drivers. The Uniform CD-ROM Driver now provides another
129 software-level, that separates the *ioctl()* and *open()* implementation
130 from the actual hardware implementation. Note that this effort has
131 made few changes which will affect a user's application programs. The
132 greatest change involved moving the contents of the various low-level
133 CD-ROM drivers\' header files to the kernel's cdrom directory. This was
134 done to help ensure that the user is only presented with only one cdrom
135 interface, the interface defined in `cdrom.h`.
136
137 CD-ROM drives are specific enough (i. e., different from other
138 block-devices such as floppy or hard disc drives), to define a set
139 of common **CD-ROM device operations**, *<cdrom-device>_dops*.
140 These operations are different from the classical block-device file
141 operations, *<block-device>_fops*.
142
143 The routines for the Uniform CD-ROM Driver interface level are implemented
144 in the file `cdrom.c`. In this file, the Uniform CD-ROM Driver interfaces
145 with the kernel as a block device by registering the following general
146 *struct file_operations*::
147
148 struct file_operations cdrom_fops = {
149 NULL, /* lseek */
150 block _read , /* read--general block-dev read */
151 block _write, /* write--general block-dev write */
152 NULL, /* readdir */
153 NULL, /* select */
154 cdrom_ioctl, /* ioctl */
155 NULL, /* mmap */
156 cdrom_open, /* open */
157 cdrom_release, /* release */
158 NULL, /* fsync */
159 NULL, /* fasync */
160 NULL /* revalidate */
161 };
162
163 Every active CD-ROM device shares this *struct*. The routines
164 declared above are all implemented in `cdrom.c`, since this file is the
165 place where the behavior of all CD-ROM-devices is defined and
166 standardized. The actual interface to the various types of CD-ROM
167 hardware is still performed by various low-level CD-ROM-device
168 drivers. These routines simply implement certain **capabilities**
169 that are common to all CD-ROM (and really, all removable-media
170 devices).
171
172 Registration of a low-level CD-ROM device driver is now done through
173 the general routines in `cdrom.c`, not through the Virtual File System
174 (VFS) any more. The interface implemented in `cdrom.c` is carried out
175 through two general structures that contain information about the
176 capabilities of the driver, and the specific drives on which the
177 driver operates. The structures are:
178
179 cdrom_device_ops
180 This structure contains information about the low-level driver for a
181 CD-ROM device. This structure is conceptually connected to the major
182 number of the device (although some drivers may have different
183 major numbers, as is the case for the IDE driver).
184
185 cdrom_device_info
186 This structure contains information about a particular CD-ROM drive,
187 such as its device name, speed, etc. This structure is conceptually
188 connected to the minor number of the device.
189
190 Registering a particular CD-ROM drive with the Uniform CD-ROM Driver
191 is done by the low-level device driver though a call to::
192
193 register_cdrom(struct cdrom_device_info * <device>_info)
194
195 The device information structure, *<device>_info*, contains all the
196 information needed for the kernel to interface with the low-level
197 CD-ROM device driver. One of the most important entries in this
198 structure is a pointer to the *cdrom_device_ops* structure of the
199 low-level driver.
200
201 The device operations structure, *cdrom_device_ops*, contains a list
202 of pointers to the functions which are implemented in the low-level
203 device driver. When `cdrom.c` accesses a CD-ROM device, it does it
204 through the functions in this structure. It is impossible to know all
205 the capabilities of future CD-ROM drives, so it is expected that this
206 list may need to be expanded from time to time as new technologies are
207 developed. For example, CD-R and CD-R/W drives are beginning to become
208 popular, and support will soon need to be added for them. For now, the
209 current *struct* is::
210
211 struct cdrom_device_ops {
212 int (*open)(struct cdrom_device_info *, int)
213 void (*release)(struct cdrom_device_info *);
214 int (*drive_status)(struct cdrom_device_info *, int);
215 unsigned int (*check_events)(struct cdrom_device_info *,
216 unsigned int, int);
217 int (*media_changed)(struct cdrom_device_info *, int);
218 int (*tray_move)(struct cdrom_device_info *, int);
219 int (*lock_door)(struct cdrom_device_info *, int);
220 int (*select_speed)(struct cdrom_device_info *, unsigned long);
221 int (*get_last_session) (struct cdrom_device_info *,
222 struct cdrom_multisession *);
223 int (*get_mcn)(struct cdrom_device_info *, struct cdrom_mcn *);
224 int (*reset)(struct cdrom_device_info *);
225 int (*audio_ioctl)(struct cdrom_device_info *,
226 unsigned int, void *);
227 const int capability; /* capability flags */
228 int (*generic_packet)(struct cdrom_device_info *,
229 struct packet_command *);
230 };
231
232 When a low-level device driver implements one of these capabilities,
233 it should add a function pointer to this *struct*. When a particular
234 function is not implemented, however, this *struct* should contain a
235 NULL instead. The *capability* flags specify the capabilities of the
236 CD-ROM hardware and/or low-level CD-ROM driver when a CD-ROM drive
237 is registered with the Uniform CD-ROM Driver.
238
239 Note that most functions have fewer parameters than their
240 *blkdev_fops* counterparts. This is because very little of the
241 information in the structures *inode* and *file* is used. For most
242 drivers, the main parameter is the *struct* *cdrom_device_info*, from
243 which the major and minor number can be extracted. (Most low-level
244 CD-ROM drivers don't even look at the major and minor number though,
245 since many of them only support one device.) This will be available
246 through *dev* in *cdrom_device_info* described below.
247
248 The drive-specific, minor-like information that is registered with
249 `cdrom.c`, currently contains the following fields::
250
251 struct cdrom_device_info {
252 const struct cdrom_device_ops * ops; /* device operations for this major */
253 struct list_head list; /* linked list of all device_info */
254 struct gendisk * disk; /* matching block layer disk */
255 void * handle; /* driver-dependent data */
256
257 int mask; /* mask of capability: disables them */
258 int speed; /* maximum speed for reading data */
259 int capacity; /* number of discs in a jukebox */
260
261 unsigned int options:30; /* options flags */
262 unsigned mc_flags:2; /* media-change buffer flags */
263 unsigned int vfs_events; /* cached events for vfs path */
264 unsigned int ioctl_events; /* cached events for ioctl path */
265 int use_count; /* number of times device is opened */
266 char name[20]; /* name of the device type */
267
268 __u8 sanyo_slot : 2; /* Sanyo 3-CD changer support */
269 __u8 keeplocked : 1; /* CDROM_LOCKDOOR status */
270 __u8 reserved : 5; /* not used yet */
271 int cdda_method; /* see CDDA_* flags */
272 __u8 last_sense; /* saves last sense key */
273 __u8 media_written; /* dirty flag, DVD+RW bookkeeping */
274 unsigned short mmc3_profile; /* current MMC3 profile */
275 int for_data; /* unknown:TBD */
276 int mrw_mode_page; /* which MRW mode page is in use */
277 };
278
279 Using this *struct*, a linked list of the registered minor devices is
280 built, using the *next* field. The device number, the device operations
281 struct and specifications of properties of the drive are stored in this
282 structure.
283
284 The *mask* flags can be used to mask out some of the capabilities listed
285 in *ops->capability*, if a specific drive doesn't support a feature
286 of the driver. The value *speed* specifies the maximum head-rate of the
287 drive, measured in units of normal audio speed (176kB/sec raw data or
288 150kB/sec file system data). The parameters are declared *const*
289 because they describe properties of the drive, which don't change after
290 registration.
291
292 A few registers contain variables local to the CD-ROM drive. The
293 flags *options* are used to specify how the general CD-ROM routines
294 should behave. These various flags registers should provide enough
295 flexibility to adapt to the different users' wishes (and **not** the
296 `arbitrary` wishes of the author of the low-level device driver, as is
297 the case in the old scheme). The register *mc_flags* is used to buffer
298 the information from *media_changed()* to two separate queues. Other
299 data that is specific to a minor drive, can be accessed through *handle*,
300 which can point to a data structure specific to the low-level driver.
301 The fields *use_count*, *next*, *options* and *mc_flags* need not be
302 initialized.
303
304 The intermediate software layer that `cdrom.c` forms will perform some
305 additional bookkeeping. The use count of the device (the number of
306 processes that have the device opened) is registered in *use_count*. The
307 function *cdrom_ioctl()* will verify the appropriate user-memory regions
308 for read and write, and in case a location on the CD is transferred,
309 it will `sanitize` the format by making requests to the low-level
310 drivers in a standard format, and translating all formats between the
311 user-software and low level drivers. This relieves much of the drivers'
312 memory checking and format checking and translation. Also, the necessary
313 structures will be declared on the program stack.
314
315 The implementation of the functions should be as defined in the
316 following sections. Two functions **must** be implemented, namely
317 *open()* and *release()*. Other functions may be omitted, their
318 corresponding capability flags will be cleared upon registration.
319 Generally, a function returns zero on success and negative on error. A
320 function call should return only after the command has completed, but of
321 course waiting for the device should not use processor time.
322
323 ::
324
325 int open(struct cdrom_device_info *cdi, int purpose)
326
327 *Open()* should try to open the device for a specific *purpose*, which
328 can be either:
329
330 - Open for reading data, as done by `mount()` (2), or the
331 user commands `dd` or `cat`.
332 - Open for *ioctl* commands, as done by audio-CD playing programs.
333
334 Notice that any strategic code (closing tray upon *open()*, etc.) is
335 done by the calling routine in `cdrom.c`, so the low-level routine
336 should only be concerned with proper initialization, such as spinning
337 up the disc, etc.
338
339 ::
340
341 void release(struct cdrom_device_info *cdi)
342
343 Device-specific actions should be taken such as spinning down the device.
344 However, strategic actions such as ejection of the tray, or unlocking
345 the door, should be left over to the general routine *cdrom_release()*.
346 This is the only function returning type *void*.
347
348 .. _cdrom_drive_status:
349
350 ::
351
352 int drive_status(struct cdrom_device_info *cdi, int slot_nr)
353
354 The function *drive_status*, if implemented, should provide
355 information on the status of the drive (not the status of the disc,
356 which may or may not be in the drive). If the drive is not a changer,
357 *slot_nr* should be ignored. In `cdrom.h` the possibilities are listed::
358
359
360 CDS_NO_INFO /* no information available */
361 CDS_NO_DISC /* no disc is inserted, tray is closed */
362 CDS_TRAY_OPEN /* tray is opened */
363 CDS_DRIVE_NOT_READY /* something is wrong, tray is moving? */
364 CDS_DISC_OK /* a disc is loaded and everything is fine */
365
366 ::
367
368 int tray_move(struct cdrom_device_info *cdi, int position)
369
370 This function, if implemented, should control the tray movement. (No
371 other function should control this.) The parameter *position* controls
372 the desired direction of movement:
373
374 - 0 Close tray
375 - 1 Open tray
376
377 This function returns 0 upon success, and a non-zero value upon
378 error. Note that if the tray is already in the desired position, no
379 action need be taken, and the return value should be 0.
380
381 ::
382
383 int lock_door(struct cdrom_device_info *cdi, int lock)
384
385 This function (and no other code) controls locking of the door, if the
386 drive allows this. The value of *lock* controls the desired locking
387 state:
388
389 - 0 Unlock door, manual opening is allowed
390 - 1 Lock door, tray cannot be ejected manually
391
392 This function returns 0 upon success, and a non-zero value upon
393 error. Note that if the door is already in the requested state, no
394 action need be taken, and the return value should be 0.
395
396 ::
397
398 int select_speed(struct cdrom_device_info *cdi, unsigned long speed)
399
400 Some CD-ROM drives are capable of changing their head-speed. There
401 are several reasons for changing the speed of a CD-ROM drive. Badly
402 pressed CD-ROM s may benefit from less-than-maximum head rate. Modern
403 CD-ROM drives can obtain very high head rates (up to *24x* is
404 common). It has been reported that these drives can make reading
405 errors at these high speeds, reducing the speed can prevent data loss
406 in these circumstances. Finally, some of these drives can
407 make an annoyingly loud noise, which a lower speed may reduce.
408
409 This function specifies the speed at which data is read or audio is
410 played back. The value of *speed* specifies the head-speed of the
411 drive, measured in units of standard cdrom speed (176kB/sec raw data
412 or 150kB/sec file system data). So to request that a CD-ROM drive
413 operate at 300kB/sec you would call the CDROM_SELECT_SPEED *ioctl*
414 with *speed=2*. The special value `0` means `auto-selection`, i. e.,
415 maximum data-rate or real-time audio rate. If the drive doesn't have
416 this `auto-selection` capability, the decision should be made on the
417 current disc loaded and the return value should be positive. A negative
418 return value indicates an error.
419
420 ::
421
422 int get_last_session(struct cdrom_device_info *cdi,
423 struct cdrom_multisession *ms_info)
424
425 This function should implement the old corresponding *ioctl()*. For
426 device *cdi->dev*, the start of the last session of the current disc
427 should be returned in the pointer argument *ms_info*. Note that
428 routines in `cdrom.c` have sanitized this argument: its requested
429 format will **always** be of the type *CDROM_LBA* (linear block
430 addressing mode), whatever the calling software requested. But
431 sanitization goes even further: the low-level implementation may
432 return the requested information in *CDROM_MSF* format if it wishes so
433 (setting the *ms_info->addr_format* field appropriately, of
434 course) and the routines in `cdrom.c` will make the transformation if
435 necessary. The return value is 0 upon success.
436
437 ::
438
439 int get_mcn(struct cdrom_device_info *cdi,
440 struct cdrom_mcn *mcn)
441
442 Some discs carry a `Media Catalog Number` (MCN), also called
443 `Universal Product Code` (UPC). This number should reflect the number
444 that is generally found in the bar-code on the product. Unfortunately,
445 the few discs that carry such a number on the disc don't even use the
446 same format. The return argument to this function is a pointer to a
447 pre-declared memory region of type *struct cdrom_mcn*. The MCN is
448 expected as a 13-character string, terminated by a null-character.
449
450 ::
451
452 int reset(struct cdrom_device_info *cdi)
453
454 This call should perform a hard-reset on the drive (although in
455 circumstances that a hard-reset is necessary, a drive may very well not
456 listen to commands anymore). Preferably, control is returned to the
457 caller only after the drive has finished resetting. If the drive is no
458 longer listening, it may be wise for the underlying low-level cdrom
459 driver to time out.
460
461 ::
462
463 int audio_ioctl(struct cdrom_device_info *cdi,
464 unsigned int cmd, void *arg)
465
466 Some of the CD-ROM-\ *ioctl()*\ 's defined in `cdrom.h` can be
467 implemented by the routines described above, and hence the function
468 *cdrom_ioctl* will use those. However, most *ioctl()*\ 's deal with
469 audio-control. We have decided to leave these to be accessed through a
470 single function, repeating the arguments *cmd* and *arg*. Note that
471 the latter is of type *void*, rather than *unsigned long int*.
472 The routine *cdrom_ioctl()* does do some useful things,
473 though. It sanitizes the address format type to *CDROM_MSF* (Minutes,
474 Seconds, Frames) for all audio calls. It also verifies the memory
475 location of *arg*, and reserves stack-memory for the argument. This
476 makes implementation of the *audio_ioctl()* much simpler than in the
477 old driver scheme. For example, you may look up the function
478 *cm206_audio_ioctl()* `cm206.c` that should be updated with
479 this documentation.
480
481 An unimplemented ioctl should return *-ENOSYS*, but a harmless request
482 (e. g., *CDROMSTART*) may be ignored by returning 0 (success). Other
483 errors should be according to the standards, whatever they are. When
484 an error is returned by the low-level driver, the Uniform CD-ROM Driver
485 tries whenever possible to return the error code to the calling program.
486 (We may decide to sanitize the return value in *cdrom_ioctl()* though, in
487 order to guarantee a uniform interface to the audio-player software.)
488
489 ::
490
491 int dev_ioctl(struct cdrom_device_info *cdi,
492 unsigned int cmd, unsigned long arg)
493
494 Some *ioctl()'s* seem to be specific to certain CD-ROM drives. That is,
495 they are introduced to service some capabilities of certain drives. In
496 fact, there are 6 different *ioctl()'s* for reading data, either in some
497 particular kind of format, or audio data. Not many drives support
498 reading audio tracks as data, I believe this is because of protection
499 of copyrights of artists. Moreover, I think that if audio-tracks are
500 supported, it should be done through the VFS and not via *ioctl()'s*. A
501 problem here could be the fact that audio-frames are 2352 bytes long,
502 so either the audio-file-system should ask for 75264 bytes at once
503 (the least common multiple of 512 and 2352), or the drivers should
504 bend their backs to cope with this incoherence (to which I would be
505 opposed). Furthermore, it is very difficult for the hardware to find
506 the exact frame boundaries, since there are no synchronization headers
507 in audio frames. Once these issues are resolved, this code should be
508 standardized in `cdrom.c`.
509
510 Because there are so many *ioctl()'s* that seem to be introduced to
511 satisfy certain drivers [#f2]_, any non-standard *ioctl()*\ s
512 are routed through the call *dev_ioctl()*. In principle, `private`
513 *ioctl()*\ 's should be numbered after the device's major number, and not
514 the general CD-ROM *ioctl* number, `0x53`. Currently the
515 non-supported *ioctl()'s* are:
516
517 CDROMREADMODE1, CDROMREADMODE2, CDROMREADAUDIO, CDROMREADRAW,
518 CDROMREADCOOKED, CDROMSEEK, CDROMPLAY-BLK and CDROM-READALL
519
520 .. [#f2]
521
522 Is there software around that actually uses these? I'd be interested!
523
524 .. _cdrom_capabilities:
525
526 CD-ROM capabilities
527 -------------------
528
529 Instead of just implementing some *ioctl* calls, the interface in
530 `cdrom.c` supplies the possibility to indicate the **capabilities**
531 of a CD-ROM drive. This can be done by ORing any number of
532 capability-constants that are defined in `cdrom.h` at the registration
533 phase. Currently, the capabilities are any of::
534
535 CDC_CLOSE_TRAY /* can close tray by software control */
536 CDC_OPEN_TRAY /* can open tray */
537 CDC_LOCK /* can lock and unlock the door */
538 CDC_SELECT_SPEED /* can select speed, in units of * sim*150 ,kB/s */
539 CDC_SELECT_DISC /* drive is juke-box */
540 CDC_MULTI_SESSION /* can read sessions *> rm1* */
541 CDC_MCN /* can read Media Catalog Number */
542 CDC_MEDIA_CHANGED /* can report if disc has changed */
543 CDC_PLAY_AUDIO /* can perform audio-functions (play, pause, etc) */
544 CDC_RESET /* hard reset device */
545 CDC_IOCTLS /* driver has non-standard ioctls */
546 CDC_DRIVE_STATUS /* driver implements drive status */
547
548 The capability flag is declared *const*, to prevent drivers from
549 accidentally tampering with the contents. The capability flags actually
550 inform `cdrom.c` of what the driver can do. If the drive found
551 by the driver does not have the capability, is can be masked out by
552 the *cdrom_device_info* variable *mask*. For instance, the SCSI CD-ROM
553 driver has implemented the code for loading and ejecting CD-ROM's, and
554 hence its corresponding flags in *capability* will be set. But a SCSI
555 CD-ROM drive might be a caddy system, which can't load the tray, and
556 hence for this drive the *cdrom_device_info* struct will have set
557 the *CDC_CLOSE_TRAY* bit in *mask*.
558
559 In the file `cdrom.c` you will encounter many constructions of the type::
560
561 if (cdo->capability & ~cdi->mask & CDC _<capability>) ...
562
563 There is no *ioctl* to set the mask... The reason is that
564 I think it is better to control the **behavior** rather than the
565 **capabilities**.
566
567 Options
568 -------
569
570 A final flag register controls the **behavior** of the CD-ROM
571 drives, in order to satisfy different users' wishes, hopefully
572 independently of the ideas of the respective author who happened to
573 have made the drive's support available to the Linux community. The
574 current behavior options are::
575
576 CDO_AUTO_CLOSE /* try to close tray upon device open() */
577 CDO_AUTO_EJECT /* try to open tray on last device close() */
578 CDO_USE_FFLAGS /* use file_pointer->f_flags to indicate purpose for open() */
579 CDO_LOCK /* try to lock door if device is opened */
580 CDO_CHECK_TYPE /* ensure disc type is data if opened for data */
581
582 The initial value of this register is
583 `CDO_AUTO_CLOSE | CDO_USE_FFLAGS | CDO_LOCK`, reflecting my own view on user
584 interface and software standards. Before you protest, there are two
585 new *ioctl()'s* implemented in `cdrom.c`, that allow you to control the
586 behavior by software. These are::
587
588 CDROM_SET_OPTIONS /* set options specified in (int)arg */
589 CDROM_CLEAR_OPTIONS /* clear options specified in (int)arg */
590
591 One option needs some more explanation: *CDO_USE_FFLAGS*. In the next
592 newsection we explain what the need for this option is.
593
594 A software package `setcd`, available from the Debian distribution
595 and `sunsite.unc.edu`, allows user level control of these flags.
596
597
598 The need to know the purpose of opening the CD-ROM device
599 =========================================================
600
601 Traditionally, Unix devices can be used in two different `modes`,
602 either by reading/writing to the device file, or by issuing
603 controlling commands to the device, by the device's *ioctl()*
604 call. The problem with CD-ROM drives, is that they can be used for
605 two entirely different purposes. One is to mount removable
606 file systems, CD-ROM's, the other is to play audio CD's. Audio commands
607 are implemented entirely through *ioctl()\'s*, presumably because the
608 first implementation (SUN?) has been such. In principle there is
609 nothing wrong with this, but a good control of the `CD player` demands
610 that the device can **always** be opened in order to give the
611 *ioctl* commands, regardless of the state the drive is in.
612
613 On the other hand, when used as a removable-media disc drive (what the
614 original purpose of CD-ROM s is) we would like to make sure that the
615 disc drive is ready for operation upon opening the device. In the old
616 scheme, some CD-ROM drivers don't do any integrity checking, resulting
617 in a number of i/o errors reported by the VFS to the kernel when an
618 attempt for mounting a CD-ROM on an empty drive occurs. This is not a
619 particularly elegant way to find out that there is no CD-ROM inserted;
620 it more-or-less looks like the old IBM-PC trying to read an empty floppy
621 drive for a couple of seconds, after which the system complains it
622 can't read from it. Nowadays we can **sense** the existence of a
623 removable medium in a drive, and we believe we should exploit that
624 fact. An integrity check on opening of the device, that verifies the
625 availability of a CD-ROM and its correct type (data), would be
626 desirable.
627
628 These two ways of using a CD-ROM drive, principally for data and
629 secondarily for playing audio discs, have different demands for the
630 behavior of the *open()* call. Audio use simply wants to open the
631 device in order to get a file handle which is needed for issuing
632 *ioctl* commands, while data use wants to open for correct and
633 reliable data transfer. The only way user programs can indicate what
634 their *purpose* of opening the device is, is through the *flags*
635 parameter (see `open(2)`). For CD-ROM devices, these flags aren't
636 implemented (some drivers implement checking for write-related flags,
637 but this is not strictly necessary if the device file has correct
638 permission flags). Most option flags simply don't make sense to
639 CD-ROM devices: *O_CREAT*, *O_NOCTTY*, *O_TRUNC*, *O_APPEND*, and
640 *O_SYNC* have no meaning to a CD-ROM.
641
642 We therefore propose to use the flag *O_NONBLOCK* to indicate
643 that the device is opened just for issuing *ioctl*
644 commands. Strictly, the meaning of *O_NONBLOCK* is that opening and
645 subsequent calls to the device don't cause the calling process to
646 wait. We could interpret this as don't wait until someone has
647 inserted some valid data-CD-ROM. Thus, our proposal of the
648 implementation for the *open()* call for CD-ROM s is:
649
650 - If no other flags are set than *O_RDONLY*, the device is opened
651 for data transfer, and the return value will be 0 only upon successful
652 initialization of the transfer. The call may even induce some actions
653 on the CD-ROM, such as closing the tray.
654 - If the option flag *O_NONBLOCK* is set, opening will always be
655 successful, unless the whole device doesn't exist. The drive will take
656 no actions whatsoever.
657
658 And what about standards?
659 -------------------------
660
661 You might hesitate to accept this proposal as it comes from the
662 Linux community, and not from some standardizing institute. What
663 about SUN, SGI, HP and all those other Unix and hardware vendors?
664 Well, these companies are in the lucky position that they generally
665 control both the hardware and software of their supported products,
666 and are large enough to set their own standard. They do not have to
667 deal with a dozen or more different, competing hardware
668 configurations\ [#f3]_.
669
670 .. [#f3]
671
672 Incidentally, I think that SUN's approach to mounting CD-ROM s is very
673 good in origin: under Solaris a volume-daemon automatically mounts a
674 newly inserted CD-ROM under `/cdrom/*<volume-name>*`.
675
676 In my opinion they should have pushed this
677 further and have **every** CD-ROM on the local area network be
678 mounted at the similar location, i. e., no matter in which particular
679 machine you insert a CD-ROM, it will always appear at the same
680 position in the directory tree, on every system. When I wanted to
681 implement such a user-program for Linux, I came across the
682 differences in behavior of the various drivers, and the need for an
683 *ioctl* informing about media changes.
684
685 We believe that using *O_NONBLOCK* to indicate that a device is being opened
686 for *ioctl* commands only can be easily introduced in the Linux
687 community. All the CD-player authors will have to be informed, we can
688 even send in our own patches to the programs. The use of *O_NONBLOCK*
689 has most likely no influence on the behavior of the CD-players on
690 other operating systems than Linux. Finally, a user can always revert
691 to old behavior by a call to
692 *ioctl(file_descriptor, CDROM_CLEAR_OPTIONS, CDO_USE_FFLAGS)*.
693
694 The preferred strategy of *open()*
695 ----------------------------------
696
697 The routines in `cdrom.c` are designed in such a way that run-time
698 configuration of the behavior of CD-ROM devices (of **any** type)
699 can be carried out, by the *CDROM_SET/CLEAR_OPTIONS* *ioctls*. Thus, various
700 modes of operation can be set:
701
702 `CDO_AUTO_CLOSE | CDO_USE_FFLAGS | CDO_LOCK`
703 This is the default setting. (With *CDO_CHECK_TYPE* it will be better, in
704 the future.) If the device is not yet opened by any other process, and if
705 the device is being opened for data (*O_NONBLOCK* is not set) and the
706 tray is found to be open, an attempt to close the tray is made. Then,
707 it is verified that a disc is in the drive and, if *CDO_CHECK_TYPE* is
708 set, that it contains tracks of type `data mode 1`. Only if all tests
709 are passed is the return value zero. The door is locked to prevent file
710 system corruption. If the drive is opened for audio (*O_NONBLOCK* is
711 set), no actions are taken and a value of 0 will be returned.
712
713 `CDO_AUTO_CLOSE | CDO_AUTO_EJECT | CDO_LOCK`
714 This mimics the behavior of the current sbpcd-driver. The option flags are
715 ignored, the tray is closed on the first open, if necessary. Similarly,
716 the tray is opened on the last release, i. e., if a CD-ROM is unmounted,
717 it is automatically ejected, such that the user can replace it.
718
719 We hope that these option can convince everybody (both driver
720 maintainers and user program developers) to adopt the new CD-ROM
721 driver scheme and option flag interpretation.
722
723 Description of routines in `cdrom.c`
724 ====================================
725
726 Only a few routines in `cdrom.c` are exported to the drivers. In this
727 new section we will discuss these, as well as the functions that `take
728 over` the CD-ROM interface to the kernel. The header file belonging
729 to `cdrom.c` is called `cdrom.h`. Formerly, some of the contents of this
730 file were placed in the file `ucdrom.h`, but this file has now been
731 merged back into `cdrom.h`.
732
733 ::
734
735 struct file_operations cdrom_fops
736
737 The contents of this structure were described in cdrom_api_.
738 A pointer to this structure is assigned to the *fops* field
739 of the *struct gendisk*.
740
741 ::
742
743 int register_cdrom(struct cdrom_device_info *cdi)
744
745 This function is used in about the same way one registers *cdrom_fops*
746 with the kernel, the device operations and information structures,
747 as described in cdrom_api_, should be registered with the
748 Uniform CD-ROM Driver::
749
750 register_cdrom(&<device>_info);
751
752
753 This function returns zero upon success, and non-zero upon
754 failure. The structure *<device>_info* should have a pointer to the
755 driver's *<device>_dops*, as in::
756
757 struct cdrom_device_info <device>_info = {
758 <device>_dops;
759 ...
760 }
761
762 Note that a driver must have one static structure, *<device>_dops*, while
763 it may have as many structures *<device>_info* as there are minor devices
764 active. *Register_cdrom()* builds a linked list from these.
765
766
767 ::
768
769 void unregister_cdrom(struct cdrom_device_info *cdi)
770
771 Unregistering device *cdi* with minor number *MINOR(cdi->dev)* removes
772 the minor device from the list. If it was the last registered minor for
773 the low-level driver, this disconnects the registered device-operation
774 routines from the CD-ROM interface. This function returns zero upon
775 success, and non-zero upon failure.
776
777 ::
778
779 int cdrom_open(struct inode * ip, struct file * fp)
780
781 This function is not called directly by the low-level drivers, it is
782 listed in the standard *cdrom_fops*. If the VFS opens a file, this
783 function becomes active. A strategy is implemented in this routine,
784 taking care of all capabilities and options that are set in the
785 *cdrom_device_ops* connected to the device. Then, the program flow is
786 transferred to the device_dependent *open()* call.
787
788 ::
789
790 void cdrom_release(struct inode *ip, struct file *fp)
791
792 This function implements the reverse-logic of *cdrom_open()*, and then
793 calls the device-dependent *release()* routine. When the use-count has
794 reached 0, the allocated buffers are flushed by calls to *sync_dev(dev)*
795 and *invalidate_buffers(dev)*.
796
797
798 .. _cdrom_ioctl:
799
800 ::
801
802 int cdrom_ioctl(struct inode *ip, struct file *fp,
803 unsigned int cmd, unsigned long arg)
804
805 This function handles all the standard *ioctl* requests for CD-ROM
806 devices in a uniform way. The different calls fall into three
807 categories: *ioctl()'s* that can be directly implemented by device
808 operations, ones that are routed through the call *audio_ioctl()*, and
809 the remaining ones, that are presumable device-dependent. Generally, a
810 negative return value indicates an error.
811
812 Directly implemented *ioctl()'s*
813 --------------------------------
814
815 The following `old` CD-ROM *ioctl()*\ 's are implemented by directly
816 calling device-operations in *cdrom_device_ops*, if implemented and
817 not masked:
818
819 `CDROMMULTISESSION`
820 Requests the last session on a CD-ROM.
821 `CDROMEJECT`
822 Open tray.
823 `CDROMCLOSETRAY`
824 Close tray.
825 `CDROMEJECT_SW`
826 If *arg\not=0*, set behavior to auto-close (close
827 tray on first open) and auto-eject (eject on last release), otherwise
828 set behavior to non-moving on *open()* and *release()* calls.
829 `CDROM_GET_MCN`
830 Get the Media Catalog Number from a CD.
831
832 *Ioctl*s routed through *audio_ioctl()*
833 ---------------------------------------
834
835 The following set of *ioctl()'s* are all implemented through a call to
836 the *cdrom_fops* function *audio_ioctl()*. Memory checks and
837 allocation are performed in *cdrom_ioctl()*, and also sanitization of
838 address format (*CDROM_LBA*/*CDROM_MSF*) is done.
839
840 `CDROMSUBCHNL`
841 Get sub-channel data in argument *arg* of type
842 `struct cdrom_subchnl *`.
843 `CDROMREADTOCHDR`
844 Read Table of Contents header, in *arg* of type
845 `struct cdrom_tochdr *`.
846 `CDROMREADTOCENTRY`
847 Read a Table of Contents entry in *arg* and specified by *arg*
848 of type `struct cdrom_tocentry *`.
849 `CDROMPLAYMSF`
850 Play audio fragment specified in Minute, Second, Frame format,
851 delimited by *arg* of type `struct cdrom_msf *`.
852 `CDROMPLAYTRKIND`
853 Play audio fragment in track-index format delimited by *arg*
854 of type `struct cdrom_ti *`.
855 `CDROMVOLCTRL`
856 Set volume specified by *arg* of type `struct cdrom_volctrl *`.
857 `CDROMVOLREAD`
858 Read volume into by *arg* of type `struct cdrom_volctrl *`.
859 `CDROMSTART`
860 Spin up disc.
861 `CDROMSTOP`
862 Stop playback of audio fragment.
863 `CDROMPAUSE`
864 Pause playback of audio fragment.
865 `CDROMRESUME`
866 Resume playing.
867
868 New *ioctl()'s* in `cdrom.c`
869 ----------------------------
870
871 The following *ioctl()'s* have been introduced to allow user programs to
872 control the behavior of individual CD-ROM devices. New *ioctl*
873 commands can be identified by the underscores in their names.
874
875 `CDROM_SET_OPTIONS`
876 Set options specified by *arg*. Returns the option flag register
877 after modification. Use *arg = \rm0* for reading the current flags.
878 `CDROM_CLEAR_OPTIONS`
879 Clear options specified by *arg*. Returns the option flag register
880 after modification.
881 `CDROM_SELECT_SPEED`
882 Select head-rate speed of disc specified as by *arg* in units
883 of standard cdrom speed (176\,kB/sec raw data or
884 150kB/sec file system data). The value 0 means `auto-select`,
885 i. e., play audio discs at real time and data discs at maximum speed.
886 The value *arg* is checked against the maximum head rate of the
887 drive found in the *cdrom_dops*.
888 `CDROM_SELECT_DISC`
889 Select disc numbered *arg* from a juke-box.
890
891 First disc is numbered 0. The number *arg* is checked against the
892 maximum number of discs in the juke-box found in the *cdrom_dops*.
893 `CDROM_MEDIA_CHANGED`
894 Returns 1 if a disc has been changed since the last call.
895 For juke-boxes, an extra argument *arg*
896 specifies the slot for which the information is given. The special
897 value *CDSL_CURRENT* requests that information about the currently
898 selected slot be returned.
899 `CDROM_TIMED_MEDIA_CHANGE`
900 Checks whether the disc has been changed since a user supplied time
901 and returns the time of the last disc change.
902
903 *arg* is a pointer to a *cdrom_timed_media_change_info* struct.
904 *arg->last_media_change* may be set by calling code to signal
905 the timestamp of the last known media change (by the caller).
906 Upon successful return, this ioctl call will set
907 *arg->last_media_change* to the latest media change timestamp (in ms)
908 known by the kernel/driver and set *arg->has_changed* to 1 if
909 that timestamp is more recent than the timestamp set by the caller.
910 `CDROM_DRIVE_STATUS`
911 Returns the status of the drive by a call to
912 *drive_status()*. Return values are defined in cdrom_drive_status_.
913 Note that this call doesn't return information on the
914 current playing activity of the drive; this can be polled through
915 an *ioctl* call to *CDROMSUBCHNL*. For juke-boxes, an extra argument
916 *arg* specifies the slot for which (possibly limited) information is
917 given. The special value *CDSL_CURRENT* requests that information
918 about the currently selected slot be returned.
919 `CDROM_DISC_STATUS`
920 Returns the type of the disc currently in the drive.
921 It should be viewed as a complement to *CDROM_DRIVE_STATUS*.
922 This *ioctl* can provide *some* information about the current
923 disc that is inserted in the drive. This functionality used to be
924 implemented in the low level drivers, but is now carried out
925 entirely in Uniform CD-ROM Driver.
926
927 The history of development of the CD's use as a carrier medium for
928 various digital information has lead to many different disc types.
929 This *ioctl* is useful only in the case that CDs have \emph {only
930 one} type of data on them. While this is often the case, it is
931 also very common for CDs to have some tracks with data, and some
932 tracks with audio. Because this is an existing interface, rather
933 than fixing this interface by changing the assumptions it was made
934 under, thereby breaking all user applications that use this
935 function, the Uniform CD-ROM Driver implements this *ioctl* as
936 follows: If the CD in question has audio tracks on it, and it has
937 absolutely no CD-I, XA, or data tracks on it, it will be reported
938 as *CDS_AUDIO*. If it has both audio and data tracks, it will
939 return *CDS_MIXED*. If there are no audio tracks on the disc, and
940 if the CD in question has any CD-I tracks on it, it will be
941 reported as *CDS_XA_2_2*. Failing that, if the CD in question
942 has any XA tracks on it, it will be reported as *CDS_XA_2_1*.
943 Finally, if the CD in question has any data tracks on it,
944 it will be reported as a data CD (*CDS_DATA_1*).
945
946 This *ioctl* can return::
947
948 CDS_NO_INFO /* no information available */
949 CDS_NO_DISC /* no disc is inserted, or tray is opened */
950 CDS_AUDIO /* Audio disc (2352 audio bytes/frame) */
951 CDS_DATA_1 /* data disc, mode 1 (2048 user bytes/frame) */
952 CDS_XA_2_1 /* mixed data (XA), mode 2, form 1 (2048 user bytes) */
953 CDS_XA_2_2 /* mixed data (XA), mode 2, form 1 (2324 user bytes) */
954 CDS_MIXED /* mixed audio/data disc */
955
956 For some information concerning frame layout of the various disc
957 types, see a recent version of `cdrom.h`.
958
959 `CDROM_CHANGER_NSLOTS`
960 Returns the number of slots in a juke-box.
961 `CDROMRESET`
962 Reset the drive.
963 `CDROM_GET_CAPABILITY`
964 Returns the *capability* flags for the drive. Refer to section
965 cdrom_capabilities_ for more information on these flags.
966 `CDROM_LOCKDOOR`
967 Locks the door of the drive. `arg == 0` unlocks the door,
968 any other value locks it.
969 `CDROM_DEBUG`
970 Turns on debugging info. Only root is allowed to do this.
971 Same semantics as CDROM_LOCKDOOR.
972
973
974 Device dependent *ioctl()'s*
975 ----------------------------
976
977 Finally, all other *ioctl()'s* are passed to the function *dev_ioctl()*,
978 if implemented. No memory allocation or verification is carried out.
979
980 How to update your driver
981 =========================
982
983 - Make a backup of your current driver.
984 - Get hold of the files `cdrom.c` and `cdrom.h`, they should be in
985 the directory tree that came with this documentation.
986 - Make sure you include `cdrom.h`.
987 - Change the 3rd argument of *register_blkdev* from `&<your-drive>_fops`
988 to `&cdrom_fops`.
989 - Just after that line, add the following to register with the Uniform
990 CD-ROM Driver::
991
992 register_cdrom(&<your-drive>_info);*
993
994 Similarly, add a call to *unregister_cdrom()* at the appropriate place.
995 - Copy an example of the device-operations *struct* to your
996 source, e. g., from `cm206.c` *cm206_dops*, and change all
997 entries to names corresponding to your driver, or names you just
998 happen to like. If your driver doesn't support a certain function,
999 make the entry *NULL*. At the entry *capability* you should list all
1000 capabilities your driver currently supports. If your driver
1001 has a capability that is not listed, please send me a message.
1002 - Copy the *cdrom_device_info* declaration from the same example
1003 driver, and modify the entries according to your needs. If your
1004 driver dynamically determines the capabilities of the hardware, this
1005 structure should also be declared dynamically.
1006 - Implement all functions in your `<device>_dops` structure,
1007 according to prototypes listed in `cdrom.h`, and specifications given
1008 in cdrom_api_. Most likely you have already implemented
1009 the code in a large part, and you will almost certainly need to adapt the
1010 prototype and return values.
1011 - Rename your `<device>_ioctl()` function to *audio_ioctl* and
1012 change the prototype a little. Remove entries listed in the first
1013 part in cdrom_ioctl_, if your code was OK, these are
1014 just calls to the routines you adapted in the previous step.
1015 - You may remove all remaining memory checking code in the
1016 *audio_ioctl()* function that deals with audio commands (these are
1017 listed in the second part of cdrom_ioctl_. There is no
1018 need for memory allocation either, so most *case*s in the *switch*
1019 statement look similar to::
1021 case CDROMREADTOCENTRY:
1022 get_toc_entry\bigl((struct cdrom_tocentry *) arg);
1024 - All remaining *ioctl* cases must be moved to a separate
1025 function, *<device>_ioctl*, the device-dependent *ioctl()'s*. Note that
1026 memory checking and allocation must be kept in this code!
1027 - Change the prototypes of *<device>_open()* and
1028 *<device>_release()*, and remove any strategic code (i. e., tray
1029 movement, door locking, etc.).
1030 - Try to recompile the drivers. We advise you to use modules, both
1031 for `cdrom.o` and your driver, as debugging is much easier this
1032 way.
1034 Thanks
1035 ======
1037 Thanks to all the people involved. First, Erik Andersen, who has
1038 taken over the torch in maintaining `cdrom.c` and integrating much
1039 CD-ROM-related code in the 2.1-kernel. Thanks to Scott Snyder and
1040 Gerd Knorr, who were the first to implement this interface for SCSI
1041 and IDE-CD drivers and added many ideas for extension of the data
1042 structures relative to kernel~2.0. Further thanks to Heiko Eißfeldt,
1043 Thomas Quinot, Jon Tombs, Ken Pizzini, Eberhard Mönkeberg and Andrew Kroll,
1044 the Linux CD-ROM device driver developers who were kind
1045 enough to give suggestions and criticisms during the writing. Finally
1046 of course, I want to thank Linus Torvalds for making this possible in
1047 the first place.

3. 한국어 전문 번역

영어 원문의 문단 순서와 의미를 유지한 전체 번역입니다. 코드, 함수명, symbol과 URL은 원문 표기를 유지합니다.

문서 정보와 Uniform CD-ROM 인터페이스의 배경

1-43

`A Linux CD-ROM standard`는 David van Leeuwen이 1999년 3월 12일 작성하고 Erik Andersen과 Jens Axboe가 갱신한 Linux CD-ROM 표준 문서입니다.

Linux가 매우 다양한 hardware device를 지원하는 이유로 문서는 여러 platform에서 쓸 수 있는 방대한 device 목록, 누구나 driver를 작성할 수 있는 개방형 운영체제 설계, 그리고 driver 작성법을 보여 주는 풍부한 source code를 듭니다.

이 개방성은 폭넓은 hardware 지원을 가능하게 했지만 device driver마다 동작이 크게 달라지는 문제도 만들었습니다. 특히 CD-ROM에서는 같은 표준 `ioctl()`에 대한 반응이 driver마다 달랐습니다. 새 driver가 기존 driver를 이해하고 복사한 뒤 수정하는 방식으로 작성되었지만 전체 Linux CD-ROM driver의 일관된 동작은 유지되지 않았습니다.

이 문서는 Linux의 서로 다른 CD-ROM device driver에 통일된 동작을 세우려는 노력, 여러 `ioctl()`의 정의와 low-level driver 구현 규칙을 설명합니다. Linux 2.1.x 개발 kernel 당시 IDE/ATAPI와 SCSI를 포함한 여러 low-level driver가 이 Uniform interface를 사용했습니다.

CD-ROM hardware interface의 역사와 동작 불일치

44-79

초기 CD-ROM 표준은 drive와 computer 사이의 interface를 규정하지 않아 수많은 방식이 생겼습니다. Sony, Mitsumi, Panasonic, Philips는 proprietary design을 사용했고, CreativeLabs/SoundBlaster, Teac, Funai는 기존 electrical interface의 기능을 바꾸었으며, Aztech, Sanyo, Funai, Vertos, Longshine, Optics Storage와 많은 `NoName` 제조사는 기존 interface 하나 이상에 drive를 맞췄습니다.

새 interface나 고유 command set·flow control을 도입한 drive에는 별도 driver를 쓰거나 기존 driver를 확장해야 했습니다. 그 결과 Linux는 다양한 interface를 지원하게 되었습니다. 현재의 거의 모든 새 drive는 IDE/ATAPI 또는 SCSI이고 새 proprietary interface가 등장할 가능성은 낮으며, 오래된 interface용 drive는 구하기도 어렵습니다.

kernel 1.3.70 무렵 `cdrom.h`의 software interface는 특정 drive의 capability를 수용하기 위해 ad hoc으로 추가된 command와 data format의 혼합물이었습니다. 더 중요한 문제는 표준 command의 동작이 driver마다 달랐다는 점입니다. tray가 열린 상태에서 `open()`하면 닫는 driver와 그렇지 않은 driver가 있었고, file system 불일치를 막으려고 문을 잠그는 driver와 software eject를 위해 잠그지 않는 driver도 있었습니다.

원 저자는 당시 살펴본 정확한 kernel version을 기억하지 못하며 자신이 간접적으로 관여한 최신 version인 1.2.13과 1.3.34였을 것으로 추정합니다.

Uniform CD-ROM Driver의 목표

80-115

저자는 Linux CD-ROM driver의 동작을 더 통일하는 논의를 시작했고 여러 driver 개발자의 호응을 바탕으로 Uniform CD-ROM Driver를 작성했습니다. 구현은 `cdrom.c`에 있으며 각 low-level CD-ROM driver 위에 놓이는 추가 software layer입니다. hardware가 허용하는 범위에서 서로 다른 CD-ROM device가 정확히 같은 방식으로 동작하게 합니다.

목표는 아직 이 방식을 지원하지 않는 driver 개발자를 배척하는 것이 아닙니다. CD-ROM application 작성자에게 모든 device에서 일관된 단 하나의 Linux CD-ROM interface를 제공하고, low-level driver code와 Linux kernel 사이에도 일관된 interface를 제공하는 것입니다.

`cdrom.h`의 data structure와 programmer interface에는 100% compatibility를 유지합니다. 이 지침은 CD-ROM driver 개발자가 code를 `cdrom.c`의 Uniform CD-ROM Driver에 맞추는 데 도움을 줍니다.

IDE/ATAPI와 SCSI가 가장 중요한 interface가 되었지만 한 사용자가 서로 다른 형식의 drive를 여러 개 가질 수 있으므로 동작 일관성은 여전히 중요합니다. 문서는 1994년의 2배속 Philips cm206 proprietary drive에서 1997년의 보편적인 16배속·24배속 drive로 빠르게 바뀐 당시의 hardware 상황도 기록합니다.

추가 software layer와 driver 등록 구조

116-200

문서 작성 당시에는 각 driver가 CD-ROM `ioctl()`을 자체 routine으로 직접 구현했습니다. 이 때문에 user data 유효성 검사 같은 중요한 작업을 빠뜨릴 위험이 있었고 driver별 동작도 갈라졌습니다.

Uniform CD-ROM Driver는 일관된 동작과 공통 서비스를 제공하며 `ioctl()`·`open()` 구현을 실제 hardware 구현에서 분리합니다. user application에 영향을 주는 변경은 적고, 가장 큰 변경은 여러 low-level driver header 내용을 kernel의 cdrom directory로 옮겨 user에게 `cdrom.h`로 정의된 interface 하나만 보이게 한 것입니다.

CD-ROM은 floppy나 hard disk 같은 다른 block device와 충분히 다르므로 고전적인 `<block-device>_fops`와 별도로 공통 CD-ROM device operation인 `<cdrom-device>_dops`를 정의합니다. `cdrom.c`는 다음 일반 `struct file_operations`를 등록하여 kernel에 block device interface를 제공합니다.

struct file_operations cdrom_fops = {
        NULL,                        /* lseek */
        block _read ,                /* read--general block-dev read */
        block _write,                /* write--general block-dev write */
        NULL,                        /* readdir */
        NULL,                        /* select */
        cdrom_ioctl,                /* ioctl */
        NULL,                        /* mmap */
        cdrom_open,                /* open */
        cdrom_release,                /* release */
        NULL,                        /* fsync */
        NULL,                        /* fasync */
        NULL                        /* revalidate */
};

모든 활성 CD-ROM device가 이 structure를 공유합니다. 표준화된 routine은 `cdrom.c`에 있고 실제 hardware 접근은 low-level driver가 수행합니다. low-level routine은 CD-ROM과 removable-media device에 공통인 capability를 구현합니다.

low-level driver 등록은 더 이상 VFS에 직접 하지 않고 `cdrom.c`의 일반 routine을 통합니다. interface는 driver capability를 나타내는 `cdrom_device_ops`와 개별 drive 정보를 나타내는 `cdrom_device_info` 두 structure를 사용합니다.

structure개념적 범위내용
cdrom_device_opsdevice major number에 대응low-level CD-ROM driver의 operation과 capability
cdrom_device_infodevice minor number에 대응개별 drive의 이름, 속도 등

개별 CD-ROM drive는 low-level driver가 다음 호출로 등록합니다.

register_cdrom(struct cdrom_device_info * <device>_info)

`<device>_info`는 kernel과 low-level driver 사이에 필요한 모든 정보를 담으며, 특히 low-level driver의 `cdrom_device_ops` structure를 가리키는 pointer가 중요합니다.

cdrom_device_ops와 capability function pointer

201-247

`cdrom_device_ops`에는 low-level driver가 구현한 function pointer 목록이 있습니다. `cdrom.c`는 이 function을 통해 device에 접근합니다. 미래 drive의 모든 capability를 미리 알 수 없으므로 새 기술이 등장하면 목록이 확장될 수 있습니다. 당시에는 CD-R과 CD-R/W 지원이 예정되어 있었습니다.

struct cdrom_device_ops {
        int (*open)(struct cdrom_device_info *, int)
        void (*release)(struct cdrom_device_info *);
        int (*drive_status)(struct cdrom_device_info *, int);
        unsigned int (*check_events)(struct cdrom_device_info *,
                                     unsigned int, int);
        int (*media_changed)(struct cdrom_device_info *, int);
        int (*tray_move)(struct cdrom_device_info *, int);
        int (*lock_door)(struct cdrom_device_info *, int);
        int (*select_speed)(struct cdrom_device_info *, unsigned long);
        int (*get_last_session) (struct cdrom_device_info *,
                                 struct cdrom_multisession *);
        int (*get_mcn)(struct cdrom_device_info *, struct cdrom_mcn *);
        int (*reset)(struct cdrom_device_info *);
        int (*audio_ioctl)(struct cdrom_device_info *,
                           unsigned int, void *);
        const int capability;                /* capability flags */
        int (*generic_packet)(struct cdrom_device_info *,
                              struct packet_command *);
};

low-level driver가 capability를 구현하면 해당 function pointer를 structure에 넣고 구현하지 않은 function에는 `NULL`을 넣습니다. `capability` flag는 Uniform CD-ROM Driver 등록 시 hardware 또는 low-level driver가 제공하는 기능을 나타냅니다.

대부분의 function은 `blkdev_fops` 대응 function보다 parameter가 적습니다. `inode`와 `file` 정보가 거의 필요하지 않기 때문입니다. 주 parameter인 `struct cdrom_device_info`에서 major와 minor number를 얻을 수 있지만, device 하나만 지원하는 많은 driver는 이 번호조차 보지 않습니다.

cdrom_device_info, mask와 공통 bookkeeping

248-322

`cdrom.c`에 등록하는 개별 drive 정보는 다음 field를 포함합니다.

struct cdrom_device_info {
      const struct cdrom_device_ops * ops;        /* device operations for this major */
      struct list_head list;                        /* linked list of all device_info */
      struct gendisk * disk;                        /* matching block layer disk */
      void *  handle;                                /* driver-dependent data */

      int mask;                                /* mask of capability: disables them */
      int speed;                                /* maximum speed for reading data */
      int capacity;                                /* number of discs in a jukebox */

      unsigned int options:30;                /* options flags */
      unsigned mc_flags:2;                        /*  media-change buffer flags */
      unsigned int vfs_events;                /*  cached events for vfs path */
      unsigned int ioctl_events;                /*  cached events for ioctl path */
      int use_count;                                /*  number of times device is opened */
      char name[20];                                /*  name of the device type */

      __u8 sanyo_slot : 2;                        /*  Sanyo 3-CD changer support */
      __u8 keeplocked : 1;                        /*  CDROM_LOCKDOOR status */
      __u8 reserved : 5;                        /*  not used yet */
      int cdda_method;                        /*  see CDDA_* flags */
      __u8 last_sense;                        /*  saves last sense key */
      __u8 media_written;                        /*  dirty flag, DVD+RW bookkeeping */
      unsigned short mmc3_profile;                /*  current MMC3 profile */
      int for_data;                                /*  unknown:TBD */
      int mrw_mode_page;                        /*  which MRW mode page is in use */
};

이 structure로 등록된 minor device의 linked list를 만들며 device number, device operation structure와 drive property를 저장합니다.

특정 drive가 driver의 `ops->capability` 가운데 일부를 지원하지 않으면 `mask`로 해당 capability를 가립니다. `speed`는 normal audio speed 단위의 maximum head rate이며 raw data 176kB/sec 또는 file system data 150kB/sec에 해당합니다. 등록 뒤 바뀌지 않는 drive property는 `const`로 선언합니다.

`options`는 일반 CD-ROM routine의 동작을 지정하여 low-level driver 작성자의 임의 선택이 아니라 user 요구에 맞출 수 있게 합니다. `mc_flags`는 `media_changed()` 정보를 두 queue에 buffer하고, minor drive 전용 data는 low-level structure를 가리키는 `handle`로 접근합니다. `use_count`, `next`, `options`, `mc_flags`는 driver가 초기화할 필요가 없습니다.

`cdrom.c` layer는 추가 bookkeeping도 수행합니다. device를 연 process 수를 `use_count`에 기록하고, `cdrom_ioctl()`은 read/write user-memory region을 검증합니다. CD 위치를 전달할 때 low-level driver에는 표준 format으로 요청하고 user software와 driver format 사이를 변환합니다. 따라서 각 driver의 memory 검사, format 검사와 변환 부담이 줄고 필요한 structure는 program stack에 마련됩니다.

`open()`과 `release()`는 반드시 구현해야 합니다. 나머지 function은 생략할 수 있으며 등록 시 대응 capability flag가 지워집니다. 일반적으로 성공은 0, 오류는 음수를 반환합니다. command가 완료된 뒤 반환하되 device를 기다리는 동안 CPU time을 소비해서는 안 됩니다.

open, release, 상태, tray와 door 제어

323-395
int open(struct cdrom_device_info *cdi, int purpose)

`open()`은 data read 목적, 즉 `mount(2)`, `dd`, `cat`이 사용하는 경우와 audio CD player가 `ioctl` command를 보내기 위한 경우를 구분해 device를 열어야 합니다. tray 닫기 같은 정책은 `cdrom.c`의 caller가 수행하므로 low-level routine은 disc spin-up 같은 올바른 초기화만 담당합니다.

void release(struct cdrom_device_info *cdi)

`release()`는 spin-down 같은 device-specific action을 수행합니다. tray eject나 door unlock 같은 정책은 일반 `cdrom_release()`에 맡기며, 이 function만 return type이 `void`입니다.

int drive_status(struct cdrom_device_info *cdi, int slot_nr)

`drive_status()`는 disc 내용이 아니라 drive 자체 상태를 제공합니다. changer가 아니면 `slot_nr`를 무시합니다. 가능한 상태는 다음과 같습니다.

CDS_NO_INFO                /* no information available */
CDS_NO_DISC                /* no disc is inserted, tray is closed */
CDS_TRAY_OPEN                /* tray is opened */
CDS_DRIVE_NOT_READY        /* something is wrong, tray is moving? */
CDS_DISC_OK                /* a disc is loaded and everything is fine */
상태의미
CDS_NO_INFO정보 없음
CDS_NO_DISCtray는 닫혔지만 disc 없음
CDS_TRAY_OPENtray 열림
CDS_DRIVE_NOT_READYtray 이동 등으로 drive 준비 안 됨
CDS_DISC_OKdisc가 있고 정상
int tray_move(struct cdrom_device_info *cdi, int position)

`tray_move()`만 tray 이동을 제어합니다. `position=0`은 닫기, `1`은 열기입니다. 성공은 0, 오류는 0이 아닌 값을 반환하며 이미 원하는 위치라면 아무 작업 없이 0을 반환합니다.

int lock_door(struct cdrom_device_info *cdi, int lock)

`lock_door()`만 door lock을 제어합니다. `lock=0`이면 잠금을 풀어 수동 개방을 허용하고 `1`이면 잠가 수동 eject를 막습니다. 이미 요청 상태라면 아무 작업 없이 0을 반환합니다.

속도, multisession, MCN과 reset

396-460
int select_speed(struct cdrom_device_info *cdi, unsigned long speed)

일부 drive는 head speed를 바꿀 수 있습니다. 품질이 나쁜 press disc의 read error와 data loss를 줄이거나 고속 drive의 소음을 낮추기 위해 maximum보다 느린 속도가 유용할 수 있습니다.

`speed`는 standard CD-ROM speed 단위이며 raw 176kB/sec 또는 file system 150kB/sec입니다. 300kB/sec는 `CDROM_SELECT_SPEED`에 `speed=2`로 요청합니다. `0`은 data maximum rate 또는 audio real-time rate의 auto-selection입니다. drive가 auto-selection을 지원하지 않으면 현재 disc에 따라 결정하고 양수를 반환하며, 음수는 오류입니다.

int get_last_session(struct cdrom_device_info *cdi,
                     struct cdrom_multisession *ms_info)

`get_last_session()`은 현재 disc의 마지막 session 시작점을 `ms_info`에 반환합니다. `cdrom.c`는 caller 요청과 무관하게 argument를 `CDROM_LBA`로 정규화합니다. low-level 구현은 `ms_info->addr_format`을 올바르게 설정하면 `CDROM_MSF`로 반환할 수도 있고 `cdrom.c`가 필요하면 변환합니다. 성공은 0입니다.

int get_mcn(struct cdrom_device_info *cdi,
            struct cdrom_mcn *mcn)

`get_mcn()`은 disc의 Media Catalog Number(MCN), 즉 Universal Product Code(UPC)를 `struct cdrom_mcn` memory에 반환합니다. product barcode 번호를 나타내지만 실제 disc format은 일관되지 않으며, 결과는 null로 끝나는 13-character string이어야 합니다.

int reset(struct cdrom_device_info *cdi)

`reset()`은 drive를 hard reset하고 가능하면 reset 완료 뒤 control을 반환합니다. hard reset이 필요한 상황에는 drive가 command를 듣지 않을 수도 있으므로 low-level driver가 timeout을 두는 편이 좋습니다.

audio_ioctl과 device-dependent ioctl

461-525
int audio_ioctl(struct cdrom_device_info *cdi,
                unsigned int cmd, void *arg)

`cdrom.h`의 일부 CD-ROM `ioctl()`은 앞의 device operation으로 구현하고 `cdrom_ioctl()`이 이를 사용합니다. audio control 관련 요청은 `cmd`와 `arg`를 전달하는 단일 `audio_ioctl()`로 보냅니다. `arg` 형식은 `unsigned long int`가 아니라 `void *`입니다.

`cdrom_ioctl()`은 모든 audio call의 address format을 Minutes, Seconds, Frames 형식인 `CDROM_MSF`로 정규화하고 `arg` memory 위치를 검증하며 argument용 stack memory를 예약합니다. 이 때문에 예전 방식보다 `audio_ioctl()` 구현이 단순해집니다.

구현하지 않은 ioctl은 `-ENOSYS`를 반환해야 하지만 `CDROMSTART`처럼 해가 없는 요청은 무시하고 성공 0을 반환할 수 있습니다. low-level driver 오류는 가능한 한 caller에게 전달하며, audio player에 통일된 interface를 보장하기 위해 `cdrom_ioctl()`이 return value를 정규화할 수도 있습니다.

int dev_ioctl(struct cdrom_device_info *cdi,
              unsigned int cmd, unsigned long arg)

특정 drive capability만을 위해 만들어진 비표준 ioctl은 `dev_ioctl()`로 보냅니다. audio track을 data로 읽는 기능은 VFS로 제공하는 편이 바람직하지만 audio frame은 2352 bytes여서 512와의 최소공배수인 75264 bytes씩 요청하거나 driver가 불일치를 처리해야 하며, audio frame에는 synchronization header가 없어 정확한 frame boundary를 찾기도 어렵습니다.

private ioctl은 일반 CD-ROM ioctl number `0x53`이 아니라 device major number 뒤에 번호를 붙이는 것이 원칙입니다. 당시 지원하지 않던 ioctl은 다음과 같습니다.

CDROMREADMODE1, CDROMREADMODE2, CDROMREADAUDIO, CDROMREADRAW,
CDROMREADCOOKED, CDROMSEEK, CDROMPLAY-BLK and CDROM-READALL

원문 각주는 실제로 이 비표준 ioctl을 사용하는 software가 있는지 묻습니다.

capability와 behavior option

526-597

`cdrom.c` interface는 ioctl 구현 여부뿐 아니라 drive capability를 명시할 수 있습니다. 등록할 때 `cdrom.h`의 capability constant를 OR하여 설정합니다.

CDC_CLOSE_TRAY                /* can close tray by software control */
CDC_OPEN_TRAY                /* can open tray */
CDC_LOCK                /* can lock and unlock the door */
CDC_SELECT_SPEED        /* can select speed, in units of * sim*150 ,kB/s */
CDC_SELECT_DISC                /* drive is juke-box */
CDC_MULTI_SESSION        /* can read sessions *> rm1* */
CDC_MCN                        /* can read Media Catalog Number */
CDC_MEDIA_CHANGED        /* can report if disc has changed */
CDC_PLAY_AUDIO                /* can perform audio-functions (play, pause, etc) */
CDC_RESET                /* hard reset device */
CDC_IOCTLS                /* driver has non-standard ioctls */
CDC_DRIVE_STATUS        /* driver implements drive status */
capability기능
CDC_CLOSE_TRAY / CDC_OPEN_TRAYsoftware로 tray 닫기 / 열기
CDC_LOCKdoor lock / unlock
CDC_SELECT_SPEED / CDC_SELECT_DISC속도 선택 / jukebox disc 선택
CDC_MULTI_SESSION / CDC_MCNsession / Media Catalog Number 읽기
CDC_MEDIA_CHANGEDdisc 변경 보고
CDC_PLAY_AUDIOplay, pause 등 audio function
CDC_RESETdevice hard reset
CDC_IOCTLS비표준 ioctl 보유
CDC_DRIVE_STATUSdrive status 구현

capability flag는 accidental 변경을 막기 위해 `const`입니다. driver code가 기능을 구현했더라도 실제 drive가 지원하지 않으면 `cdrom_device_info.mask`로 가립니다. 예를 들어 SCSI driver가 load/eject code를 갖더라도 caddy drive는 tray를 닫을 수 없으므로 `CDC_CLOSE_TRAY`를 mask합니다.

if (cdo->capability & ~cdi->mask & CDC _<capability>) ...

mask를 설정하는 ioctl은 없습니다. 문서의 설계 관점은 capability 자체보다 사용자에게 보이는 behavior를 제어하는 편이 낫다는 것입니다.

behavior option register는 다음 flag를 제공합니다.

CDO_AUTO_CLOSE        /* try to close tray upon device open() */
CDO_AUTO_EJECT        /* try to open tray on last device close() */
CDO_USE_FFLAGS        /* use file_pointer->f_flags to indicate purpose for open() */
CDO_LOCK        /* try to lock door if device is opened */
CDO_CHECK_TYPE        /* ensure disc type is data if opened for data */
option동작
CDO_AUTO_CLOSE`open()` 시 tray 닫기 시도
CDO_AUTO_EJECT마지막 close 시 tray 열기 시도
CDO_USE_FFLAGS`file_pointer->f_flags`로 open 목적 구분
CDO_LOCKdevice open 중 door lock 시도
CDO_CHECK_TYPEdata open이면 data disc인지 확인

초기값은 `CDO_AUTO_CLOSE | CDO_USE_FFLAGS | CDO_LOCK`입니다. software가 동작을 바꿀 수 있도록 다음 두 ioctl을 제공합니다.

CDROM_SET_OPTIONS        /* set options specified in (int)arg */
CDROM_CLEAR_OPTIONS        /* clear options specified in (int)arg */

`CDO_USE_FFLAGS`의 필요성은 다음 절에서 설명합니다. Debian과 `sunsite.unc.edu`에서 제공되던 `setcd` package로 user level에서 이 flag를 제어할 수 있습니다.

CD-ROM open 목적을 알아야 하는 이유

598-657

Unix device는 device file을 읽고 쓰거나 `ioctl()`로 control command를 보내는 두 방식으로 사용합니다. CD-ROM은 removable file system mount와 audio CD 재생이라는 서로 다른 목적이 있습니다. audio command는 전적으로 ioctl로 구현되므로 drive 상태와 관계없이 file handle을 얻어 command를 보낼 수 있어야 합니다.

반대로 removable-media data drive로 사용할 때는 `open()` 시 정상 동작 준비가 되었는지 확인해야 합니다. 예전 일부 driver는 integrity check를 하지 않아 빈 drive에 mount를 시도하면 VFS가 여러 I/O error를 kernel에 보고했습니다. removable medium 존재를 감지할 수 있으므로 disc가 있고 올바른 data type인지 확인하는 편이 바람직합니다.

audio open은 ioctl을 위한 handle만 필요하지만 data open은 정확하고 신뢰할 수 있는 data transfer를 요구합니다. user program이 목적을 알릴 방법은 `open(2)`의 `flags`입니다. `O_CREAT`, `O_NOCTTY`, `O_TRUNC`, `O_APPEND`, `O_SYNC` 같은 flag는 CD-ROM에는 의미가 없습니다.

따라서 문서는 `O_NONBLOCK`을 ioctl command만 보내기 위한 open 표시로 사용할 것을 제안합니다. 원래 의미인 caller가 기다리지 않는다는 규칙을 유효한 data CD 삽입을 기다리지 않는 것으로 해석합니다.

CD-ROM open 목적과 동작
flag목적성공 조건drive 동작
O_RDONLY만 설정data transfertransfer 초기화 성공tray 닫기 등 가능
O_NONBLOCK 설정ioctl controldevice 자체가 존재아무 동작도 하지 않음

flag에 따라 data transfer용 검증 경로와 control-only 경로를 구분합니다.

  • `O_RDONLY` 외 flag가 없으면 data transfer용으로 열며 초기화에 성공해야 0을 반환하고 tray를 닫을 수도 있습니다.
  • `O_NONBLOCK`이면 device 자체가 존재하지 않는 경우를 제외하고 항상 성공하며 drive에는 어떤 action도 수행하지 않습니다.

표준화 논의와 권장 open 전략

658-722

이 제안은 표준화 기관이 아니라 Linux community에서 나왔지만 SUN, SGI, HP 같은 vendor는 hardware와 software를 함께 통제하고 자체 표준을 정할 수 있었습니다. Linux는 경쟁하는 수많은 hardware 구성을 다뤄야 한다는 차이가 있습니다.

원문은 Solaris volume daemon이 새 CD-ROM을 `/cdrom/<volume-name>` 아래 자동 mount하는 방식을 긍정적으로 평가하고, 더 나아가 LAN 어느 machine에 넣어도 모든 system의 같은 directory 위치에 보이는 구상을 제시합니다. 이 user program을 Linux에 구현하려다 driver 동작 차이와 media change ioctl의 필요성을 발견했습니다.

`O_NONBLOCK`을 ioctl-only open 표시로 쓰는 규칙은 Linux에 쉽게 도입할 수 있고 다른 운영체제의 CD player 동작에도 영향이 거의 없을 것으로 보았습니다. 기존 동작으로 돌아가려면 `ioctl(file_descriptor, CDROM_CLEAR_OPTIONS, CDO_USE_FFLAGS)`를 호출합니다.

`cdrom.c`는 `CDROM_SET_OPTIONS`와 `CDROM_CLEAR_OPTIONS` ioctl을 통해 모든 형식의 CD-ROM device behavior를 runtime에 설정할 수 있습니다.

기본 `CDO_AUTO_CLOSE | CDO_USE_FFLAGS | CDO_LOCK`에서는 첫 data open에 tray가 열려 있으면 닫고 disc 존재를 확인하며, `CDO_CHECK_TYPE`이 있으면 `data mode 1` track인지도 검사합니다. 모두 통과해야 성공하고 file system 손상을 막기 위해 door를 잠급니다. `O_NONBLOCK` audio open은 아무 action 없이 0을 반환합니다.

`CDO_AUTO_CLOSE | CDO_AUTO_EJECT | CDO_LOCK`은 당시 `sbpcd` driver 동작을 흉내 냅니다. flag를 무시하고 첫 open에 tray를 닫으며 마지막 release, 즉 unmount 때 tray를 열어 disc를 교체할 수 있게 합니다.

이 option이 driver maintainer와 user program 개발자 모두에게 새 CD-ROM driver 방식과 flag 해석을 채택할 충분한 유연성을 제공하는 것이 설계 목표입니다.

cdrom.c가 제공하는 routine

723-811

`cdrom.c`가 driver에 export하는 routine은 많지 않습니다. `cdrom.h`는 이 interface의 header이며, 과거 `ucdrom.h`에 있던 내용도 다시 합쳐졌습니다.

struct file_operations cdrom_fops

`cdrom_fops` pointer는 `struct gendisk`의 `fops` field에 지정합니다.

int register_cdrom(struct cdrom_device_info *cdi)

`register_cdrom()`은 device operation과 info structure를 Uniform CD-ROM Driver에 등록합니다.

register_cdrom(&<device>_info);

성공하면 0, 실패하면 0이 아닌 값을 반환합니다. `<device>_info`는 driver의 `<device>_dops`를 가리켜야 합니다.

struct cdrom_device_info <device>_info = {
        <device>_dops;
        ...
}

driver마다 static `<device>_dops`는 하나지만 활성 minor device 수만큼 `<device>_info`를 둘 수 있고 `register_cdrom()`이 linked list를 구성합니다.

void unregister_cdrom(struct cdrom_device_info *cdi)

`unregister_cdrom()`은 `MINOR(cdi->dev)`에 해당하는 minor device를 list에서 제거합니다. low-level driver의 마지막 minor였다면 등록된 operation routine을 CD-ROM interface에서 분리합니다.

int cdrom_open(struct inode * ip, struct file * fp)

`cdrom_open()`은 low-level driver가 직접 호출하지 않고 표준 `cdrom_fops`를 통해 VFS open에서 활성화됩니다. 연결된 `cdrom_device_ops`의 capability와 option에 따른 정책을 수행한 뒤 device-dependent `open()`으로 넘깁니다.

void cdrom_release(struct inode *ip, struct file *fp)

`cdrom_release()`는 `cdrom_open()`의 반대 동작을 수행하고 device-dependent `release()`를 호출합니다. use count가 0이면 `sync_dev(dev)`와 `invalidate_buffers(dev)`로 할당된 buffer를 flush합니다.

int cdrom_ioctl(struct inode *ip, struct file *fp,
                unsigned int cmd, unsigned long arg)

`cdrom_ioctl()`은 표준 CD-ROM ioctl을 통일되게 처리합니다. 요청은 device operation으로 직접 구현하는 것, `audio_ioctl()`로 보내는 것, device-dependent 나머지의 세 범주이며 일반적으로 음수 return value는 오류입니다.

직접 구현 ioctl과 audio_ioctl 경로

812-867

다음 기존 ioctl은 구현되어 있고 mask되지 않은 `cdrom_device_ops`를 직접 호출합니다.

ioctl동작
CDROMMULTISESSION마지막 session 요청
CDROMEJECT / CDROMCLOSETRAYtray 열기 / 닫기
CDROMEJECT_SW`arg!=0`이면 first open auto-close와 last release auto-eject, 아니면 open/release에서 tray 이동 안 함
CDROM_GET_MCNMedia Catalog Number 읽기

다음 ioctl은 모두 `cdrom_fops`의 `audio_ioctl()`을 호출합니다. `cdrom_ioctl()`이 memory 검사·할당과 `CDROM_LBA`/`CDROM_MSF` address format 정규화를 담당합니다.

ioctlargument와 기능
CDROMSUBCHNL`struct cdrom_subchnl *`에 sub-channel data 반환
CDROMREADTOCHDR`struct cdrom_tochdr *`에 TOC header 반환
CDROMREADTOCENTRY`struct cdrom_tocentry *`로 지정한 TOC entry 읽기
CDROMPLAYMSF`struct cdrom_msf *`의 Minute/Second/Frame 구간 재생
CDROMPLAYTRKIND`struct cdrom_ti *`의 track-index 구간 재생
CDROMVOLCTRL / CDROMVOLREAD`struct cdrom_volctrl *`로 volume 설정 / 읽기
CDROMSTART / CDROMSTOPdisc spin-up / audio playback 정지
CDROMPAUSE / CDROMRESUME재생 일시정지 / 재개

새 option, speed, media와 drive status ioctl

868-925

`cdrom.c`는 user program이 개별 CD-ROM behavior를 제어하도록 underscore가 들어간 새 ioctl 이름을 도입했습니다.

ioctl의미
CDROM_SET_OPTIONS`arg` option을 설정하고 변경 뒤 flag register 반환; `arg=0`이면 현재 flag 읽기
CDROM_CLEAR_OPTIONS`arg` option을 지우고 변경 뒤 register 반환
CDROM_SELECT_SPEEDstandard CD-ROM speed 단위로 head rate 선택; 0은 auto-select이며 drive maximum과 대조
CDROM_SELECT_DISC0부터 시작하는 jukebox disc 선택; maximum slot과 대조
CDROM_MEDIA_CHANGED마지막 호출 뒤 disc가 바뀌면 1; jukebox는 slot 또는 `CDSL_CURRENT` 지정
CDROM_TIMED_MEDIA_CHANGEcaller timestamp 이후 변경 여부와 kernel/driver가 아는 최신 ms timestamp 반환
CDROM_DRIVE_STATUS`drive_status()` 결과 반환; 재생 상태는 `CDROMSUBCHNL`로 조회
CDROM_DISC_STATUS현재 삽입된 disc type 반환

`CDROM_TIMED_MEDIA_CHANGE`의 `arg`는 `cdrom_timed_media_change_info` pointer입니다. caller가 `last_media_change`에 마지막으로 아는 timestamp를 넣고, 성공 시 kernel/driver가 아는 최신 timestamp로 갱신되며 더 최근이면 `has_changed=1`이 됩니다.

`CDROM_DRIVE_STATUS`는 현재 drive 상태를 반환하지만 현재 재생 activity는 반환하지 않습니다. jukebox에서는 `arg`로 slot을 지정하고 `CDSL_CURRENT`는 현재 선택 slot을 뜻합니다.

`CDROM_DISC_STATUS`는 과거 low-level driver가 맡던 현재 disc type 판정을 Uniform CD-ROM Driver에서 수행하며 `CDROM_DRIVE_STATUS`를 보완합니다.

disc 형식 판정과 device-dependent ioctl

926-979

CD는 audio와 data track이 섞일 수 있어 `CDROM_DISC_STATUS`는 한 종류의 data만 있는 disc에서 가장 유용합니다. 기존 user application compatibility를 깨지 않도록 interface 가정을 바꾸지 않고 다음 우선순위로 판정합니다.

  • audio track만 있고 CD-I, XA, data track이 전혀 없으면 `CDS_AUDIO`
  • audio와 data track이 모두 있으면 `CDS_MIXED`
  • audio가 없고 CD-I track이 있으면 `CDS_XA_2_2`
  • 그렇지 않고 XA track이 있으면 `CDS_XA_2_1`
  • 그렇지 않고 data track이 있으면 mode 1 data CD인 `CDS_DATA_1`
CDS_NO_INFO        /* no information available */
CDS_NO_DISC        /* no disc is inserted, or tray is opened */
CDS_AUDIO        /* Audio disc (2352 audio bytes/frame) */
CDS_DATA_1        /* data disc, mode 1 (2048 user bytes/frame) */
CDS_XA_2_1        /* mixed data (XA), mode 2, form 1 (2048 user bytes) */
CDS_XA_2_2        /* mixed data (XA), mode 2, form 1 (2324 user bytes) */
CDS_MIXED        /* mixed audio/data disc */

frame layout 정보는 최신 `cdrom.h`를 참조합니다. `CDROM_CHANGER_NSLOTS`는 jukebox slot 수를, `CDROMRESET`은 drive reset을, `CDROM_GET_CAPABILITY`는 drive capability flag를 반환합니다. `CDROM_LOCKDOOR`는 `arg==0`이면 unlock하고 그 밖에는 lock합니다. `CDROM_DEBUG`는 root만 debugging을 켤 수 있고 lock ioctl과 같은 argument 의미를 사용합니다.

이 밖의 모든 ioctl은 구현되어 있다면 `dev_ioctl()`로 전달하며, 이 경로에서는 memory allocation이나 verification을 수행하지 않습니다.

기존 driver를 Uniform interface로 갱신하는 절차

980-1033

기존 driver를 갱신할 때는 먼저 backup하고 이 문서와 함께 제공되는 `cdrom.c`, `cdrom.h`를 확보해 `cdrom.h`를 include합니다. `register_blkdev`의 세 번째 argument를 `&<your-drive>_fops`에서 `&cdrom_fops`로 바꿉니다.

바로 뒤에서 Uniform CD-ROM Driver에 등록합니다.

register_cdrom(&<your-drive>_info);*

적절한 위치에는 `unregister_cdrom()` 호출도 추가합니다. `cm206.c`의 `cm206_dops` 같은 device operation 예를 복사해 driver 이름에 맞추고 미지원 function은 `NULL`로 둡니다. `capability`에는 지원 기능을 모두 나열하며 목록에 없는 capability가 있다면 interface 확장을 검토해야 합니다.

같은 예에서 `cdrom_device_info` 선언을 복사해 수정합니다. hardware capability를 runtime에 판정한다면 이 structure도 동적으로 선언해야 합니다.

`<device>_dops`의 모든 function을 `cdrom.h` prototype과 이 문서의 specification에 맞게 구현합니다. 기존 code를 대부분 재사용할 수 있지만 prototype과 return value는 조정해야 합니다.

`<device>_ioctl()`을 `audio_ioctl`로 이름을 바꾸고 prototype을 조정합니다. `cdrom_ioctl`의 첫 범주에 나열된 case는 앞에서 바꾼 device operation 호출이므로 제거하고, audio command의 memory 검사와 allocation도 공통 layer가 담당하므로 제거할 수 있습니다.

case CDROMREADTOCENTRY:
        get_toc_entry\bigl((struct cdrom_tocentry *) arg);

남은 ioctl case는 device-dependent `<device>_ioctl`로 옮기되 이 code에는 memory 검사와 allocation을 유지합니다. `<device>_open()`과 `<device>_release()` prototype을 바꾸고 tray 이동이나 door lock 같은 정책 code를 제거합니다.

마지막으로 driver를 다시 compile합니다. debugging이 쉬우므로 `cdrom.o`와 device driver 모두 module로 사용하는 방식을 권장합니다.

감사의 말

1034-1047

저자는 `cdrom.c` 유지보수와 Linux 2.1 kernel의 CD-ROM code 통합을 맡은 Erik Andersen, SCSI와 IDE-CD driver에 이 interface를 처음 구현하고 kernel 2.0 이후 data structure 확장 아이디어를 더한 Scott Snyder와 Gerd Knorr에게 감사를 전합니다.

또한 문서 작성 중 제안과 비판을 제공한 CD-ROM driver 개발자 Heiko Eißfeldt, Thomas Quinot, Jon Tombs, Ken Pizzini, Eberhard Mönkeberg, Andrew Kroll과 이 모든 일을 가능하게 한 Linus Torvalds에게 감사를 표합니다.