xref: /illumos-gate/usr/src/cmd/cdrw/trackio.c (revision 2a8bcb4efb45d99ac41c94a75c396b362c414f7f)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #include <thread.h>
28 #include <synch.h>
29 #include <errno.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <sys/types.h>
33 #include <signal.h>
34 #include <unistd.h>
35 #include <stdio.h>
36 
37 #include "device.h"
38 #include "bstream.h"
39 #include "trackio.h"
40 #include "util.h"
41 #include "mmc.h"
42 #include "transport.h"
43 #include "misc_scsi.h"
44 #include "main.h"
45 
46 /*
47  * tio data
48  */
49 static struct iobuf	tio_iobs[NIOBS];
50 static uchar_t		tio_synch_initialized, tio_abort, tio_done;
51 static int		tio_errno;
52 static mutex_t		tio_mutex;
53 static cond_t		tio_cond;
54 static int		tio_fd, tio_trackno;
55 static int		tio_got_ctrl_c;
56 
57 /*
58  * Progress call back data.
59  */
60 static mutex_t	pcb_mutex;
61 static cond_t	pcb_cond;
62 static uchar_t	pcb_user_abort, pcb_done, pcb_synch_initialized;
63 static int64_t	pcb_completed_io_size;
64 static int	(*pcb_cb)(int64_t, int64_t);
65 static int64_t	pcb_arg;
66 
67 static void
fini_tio_data(void)68 fini_tio_data(void)
69 {
70 	int i;
71 	for (i = 0; i < NIOBS; i++) {
72 		if (tio_iobs[i].iob_buf) {
73 			free(tio_iobs[i].iob_buf);
74 			tio_iobs[i].iob_buf = NULL;
75 		}
76 	}
77 	if (tio_synch_initialized == 1) {
78 		(void) mutex_destroy(&tio_mutex);
79 		(void) cond_destroy(&tio_cond);
80 		tio_synch_initialized = 0;
81 	}
82 	tio_abort = tio_done = 0;
83 }
84 
85 static void
init_tio_data(int bsize)86 init_tio_data(int bsize)
87 {
88 	int i;
89 
90 	(void) memset(tio_iobs, 0, sizeof (tio_iobs));
91 	for (i = 0; i < NIOBS; i++) {
92 		tio_iobs[i].iob_buf = (uchar_t *)my_zalloc(bsize);
93 		tio_iobs[i].iob_total_size = bsize;
94 		tio_iobs[i].iob_state = IOBS_EMPTY;
95 	}
96 	(void) mutex_init(&tio_mutex, USYNC_THREAD, 0);
97 	(void) cond_init(&tio_cond, USYNC_THREAD, 0);
98 	tio_synch_initialized = 1;
99 	tio_abort = tio_done = 0;
100 	tio_got_ctrl_c = 0;
101 }
102 
103 static void
init_pcb_data(void)104 init_pcb_data(void)
105 {
106 	(void) mutex_init(&pcb_mutex, USYNC_THREAD, 0);
107 	(void) cond_init(&pcb_cond, USYNC_THREAD, 0);
108 	pcb_user_abort = pcb_done = 0;
109 	pcb_completed_io_size = 0;
110 	pcb_synch_initialized = 1;
111 }
112 
113 static void
fini_pcb_data(void)114 fini_pcb_data(void)
115 {
116 	if (pcb_synch_initialized == 1) {
117 		(void) mutex_destroy(&pcb_mutex);
118 		(void) cond_destroy(&pcb_cond);
119 		pcb_synch_initialized = 0;
120 	}
121 	pcb_user_abort = pcb_done = 0;
122 	pcb_completed_io_size = 0;
123 }
124 
125 /* ARGSUSED */
126 static void *
write_to_cd(void * arg)127 write_to_cd(void *arg)
128 {
129 	int i;
130 
131 	i = 0;
132 #ifndef lint
133 	while (1) {
134 #endif
135 		(void) mutex_lock(&tio_mutex);
136 		while ((tio_iobs[i].iob_state != IOBS_READY) &&
137 		    (tio_abort == 0)) {
138 			/* Wait for buffer to become ready */
139 			(void) cond_wait(&tio_cond, &tio_mutex);
140 		}
141 		if (tio_abort == 1) {
142 			/* Do a flush cache before aborting */
143 			(void) flush_cache(tio_fd);
144 			(void) mutex_unlock(&tio_mutex);
145 			thr_exit((void *)1);
146 		}
147 		tio_iobs[i].iob_state = IOBS_UNDER_DEVICE_IO;
148 
149 		/* If no more data, then close the track */
150 		if (tio_iobs[i].iob_data_size == 0) {
151 			int retry = 20;
152 
153 			/* Some drives misbehave if flush_cache is not done */
154 			(void) flush_cache(tio_fd);
155 
156 			if (write_mode == TAO_MODE) {
157 				/* Its important to try hard to close track */
158 				if (simulation)
159 					retry = 5;
160 
161 				for (; retry > 0; retry--) {
162 
163 					/* OK to hold mutex when close_track */
164 					if (close_track(tio_fd,
165 					    tio_trackno, 0, 0))
166 						break;
167 
168 					(void) sleep(1);
169 				}
170 			}
171 
172 			/* Some drives don't allow close track in test write */
173 			if ((retry == 0) && (simulation == 0)) {
174 				if (errno)
175 					tio_errno = errno;
176 				else
177 					tio_errno = -1;
178 			}
179 
180 			tio_done = 1;
181 			(void) cond_broadcast(&tio_cond);
182 			(void) mutex_unlock(&tio_mutex);
183 			thr_exit((void *)0);
184 		}
185 
186 		(void) mutex_unlock(&tio_mutex);
187 
188 		if (!write10(tio_fd, tio_iobs[i].iob_start_blk,
189 		    tio_iobs[i].iob_nblks, tio_iobs[i].iob_buf,
190 		    tio_iobs[i].iob_data_size)) {
191 
192 			int err = errno;
193 			(void) mutex_lock(&tio_mutex);
194 			if (err)
195 				tio_errno = err;
196 			else
197 				tio_errno = -1;
198 			(void) cond_broadcast(&tio_cond);
199 			(void) mutex_unlock(&tio_mutex);
200 			thr_exit((void *)2);
201 		}
202 
203 		(void) mutex_lock(&tio_mutex);
204 		tio_iobs[i].iob_state = IOBS_EMPTY;
205 		(void) cond_broadcast(&tio_cond);
206 		(void) mutex_unlock(&tio_mutex);
207 		i++;
208 		if (i == NIOBS)
209 			i = 0;
210 #ifndef lint
211 	}
212 #endif
213 	return (NULL);
214 }
215 
216 /* ARGSUSED */
217 static void *
progress_callback(void * arg)218 progress_callback(void *arg)
219 {
220 	int ret;
221 
222 pc_again:
223 	(void) mutex_lock(&pcb_mutex);
224 	if (!pcb_done) {
225 		(void) cond_wait(&pcb_cond, &pcb_mutex);
226 	}
227 	if (pcb_done) {
228 		(void) mutex_unlock(&pcb_mutex);
229 		if (tio_got_ctrl_c) {
230 			pcb_cb(pcb_arg, 0xFFFFFFFF);
231 		}
232 		thr_exit((void *)0);
233 	}
234 	(void) mutex_unlock(&pcb_mutex);
235 	ret = pcb_cb(pcb_arg, pcb_completed_io_size);
236 	if (ret != 0) {
237 		(void) mutex_lock(&pcb_mutex);
238 		pcb_user_abort = (uchar_t)ret;
239 		(void) mutex_unlock(&pcb_mutex);
240 		thr_exit((void *)0);
241 	}
242 #ifdef lint
243 	return (NULL);
244 #else
245 	goto pc_again;
246 #endif
247 }
248 
249 /* ARGSUSED */
250 static void
trackio_sig_handler(int i)251 trackio_sig_handler(int i)
252 {
253 	/* Dont need mutex as it is only modified here */
254 	tio_got_ctrl_c = 1;
255 	(void) signal(SIGINT, trackio_sig_handler);
256 }
257 
258 int
write_track(cd_device * dev,struct track_info * ti,bstreamhandle h,int (* cb)(int64_t,int64_t),int64_t arg,struct trackio_error * te)259 write_track(cd_device *dev, struct track_info *ti, bstreamhandle h,
260 	int (*cb)(int64_t, int64_t), int64_t arg, struct trackio_error *te)
261 {
262 	int			blksize, i, sz_read, rem;
263 	uint32_t		start_b;
264 	thread_t		tio_thread, pc_thread;
265 	int			write_cd_thr_created;
266 	int			progress_callback_thr_created;
267 	int			signal_handler_installed;
268 	int			retval;
269 	void			(*ohandler)(int);
270 
271 	write_cd_thr_created = progress_callback_thr_created = 0;
272 	signal_handler_installed = retval = 0;
273 
274 	if (ti->ti_track_mode & 4)
275 		blksize = DATA_TRACK_BLKSIZE;
276 	else
277 		blksize = AUDIO_TRACK_BLKSIZE;
278 
279 	/* Initialize buffers */
280 	init_tio_data(NBLKS_PER_BUF*blksize);
281 
282 	/* Fill in all buffers before starting */
283 	start_b = ti->ti_start_address;
284 
285 	/*
286 	 * Start filling initial buffer to ensure that there is plenty of
287 	 * data when writing begins.
288 	 */
289 	for (i = 0; i < NIOBS; i++) {
290 		sz_read = h->bstr_read(h, tio_iobs[i].iob_buf,
291 		    tio_iobs[i].iob_total_size);
292 
293 
294 		/*
295 		 * We need to read the source file into the buffer and make
296 		 * sure that the data in the buffer is a multiple of the
297 		 * blocksize (data or audio blocksize). iob_total_size is a
298 		 * multiple of the blocksize so this case should only be
299 		 * encountered at EOF or from piped input.
300 		 */
301 		while ((rem = (sz_read % blksize)) != 0) {
302 			int ret;
303 
304 			/*
305 			 * rem contains the amount of data past the previous
306 			 * block boundry. we need to subtract it from the
307 			 * blocksize to get the amount needed to reach the
308 			 * next block boundry.
309 			 */
310 
311 			if ((sz_read + (blksize - rem)) >
312 			    tio_iobs[i].iob_total_size) {
313 
314 			/*
315 			 * This should not occur, but we are trying to
316 			 * write past the end of the buffer. return
317 			 * with an error.
318 			 */
319 				sz_read = -1;
320 				break;
321 			}
322 
323 			/*
324 			 * Try to continue reading in case the data is being
325 			 * piped in.
326 			 */
327 			ret = h->bstr_read(h, &tio_iobs[i].iob_buf[sz_read],
328 			    (blksize - rem));
329 
330 			if (ret < 0) {
331 				sz_read = ret;
332 				break;
333 			}
334 
335 			/*
336 			 * No more data. We need to make sure that we are
337 			 * aligned with the blocksize. so pad the rest of
338 			 * the buffer with 0s
339 			 */
340 
341 			if (ret == 0) {
342 				ret = blksize - rem;
343 				(void) memset(&tio_iobs[i].iob_buf[sz_read],
344 				    0, ret);
345 			}
346 			sz_read += ret;
347 		}
348 
349 		if (sz_read < 0) {
350 
351 			/* reading the source failed, clean up and return */
352 			te->err_type = TRACKIO_ERR_SYSTEM;
353 			te->te_errno = errno;
354 			goto write_track_failed;
355 		}
356 
357 		tio_iobs[i].iob_start_blk = start_b;
358 		tio_iobs[i].iob_nblks = (sz_read/blksize);
359 		start_b += tio_iobs[i].iob_nblks;
360 		tio_iobs[i].iob_data_size = sz_read;
361 		tio_iobs[i].iob_state = IOBS_READY;
362 		if (sz_read == 0)
363 			break;
364 	}
365 
366 	tio_fd = dev->d_fd;
367 	tio_trackno = ti->ti_track_no;
368 
369 	/* Install signal handler for CTRL-C */
370 	ohandler = signal(SIGINT, trackio_sig_handler);
371 	if (ohandler) {
372 		signal_handler_installed = 1;
373 	}
374 
375 	/* Create thread which will issue commands to write to device */
376 	if (thr_create(0, 0, write_to_cd, NULL,
377 	    THR_BOUND | THR_NEW_LWP, &tio_thread) != 0) {
378 		te->err_type = TRACKIO_ERR_SYSTEM;
379 		te->te_errno = errno;
380 		goto write_track_failed;
381 	}
382 	write_cd_thr_created = 1;
383 
384 	/* If caller specified a callback, create a thread to do callbacks */
385 	if (cb != NULL) {
386 		init_pcb_data();
387 		pcb_cb = cb;
388 		pcb_arg = arg;
389 		if (thr_create(0, 0, progress_callback, NULL,
390 		    THR_BOUND | THR_NEW_LWP, &pc_thread) != 0) {
391 			te->err_type = TRACKIO_ERR_SYSTEM;
392 			te->te_errno = errno;
393 			goto write_track_failed;
394 		}
395 		progress_callback_thr_created = 1;
396 	}
397 
398 	i = 0;
399 	while (sz_read != 0) {
400 		(void) mutex_lock(&tio_mutex);
401 		while ((tio_iobs[i].iob_state != IOBS_EMPTY) &&
402 		    (tio_errno == 0) && (pcb_user_abort == 0)) {
403 
404 			/* Do callbacks only if there is nothing else to do */
405 			if (cb != NULL) {
406 				(void) mutex_lock(&pcb_mutex);
407 				(void) cond_broadcast(&pcb_cond);
408 				(void) mutex_unlock(&pcb_mutex);
409 			}
410 
411 			/* If user requested abort, bail out */
412 			if (pcb_user_abort || tio_got_ctrl_c) {
413 				break;
414 			}
415 			(void) cond_wait(&tio_cond, &tio_mutex);
416 		}
417 		if (pcb_user_abort || tio_got_ctrl_c) {
418 			(void) mutex_unlock(&tio_mutex);
419 			te->err_type = TRACKIO_ERR_USER_ABORT;
420 			goto write_track_failed;
421 		}
422 		/*
423 		 * We've got a transport error, stop writing, save all
424 		 * of the error information and clean up the threads.
425 		 */
426 		if (tio_errno != 0) {
427 			(void) mutex_unlock(&tio_mutex);
428 			te->err_type = TRACKIO_ERR_TRANSPORT;
429 			te->te_errno = tio_errno;
430 			te->status = uscsi_status;
431 			if (uscsi_status == 2) {
432 				te->key = SENSE_KEY(rqbuf) & 0xf;
433 				te->asc = ASC(rqbuf);
434 				te->ascq = ASCQ(rqbuf);
435 			}
436 			goto write_track_failed;
437 		}
438 		pcb_completed_io_size += tio_iobs[i].iob_data_size;
439 		tio_iobs[i].iob_state = IOBS_UNDER_FILE_IO;
440 		(void) mutex_unlock(&tio_mutex);
441 
442 		sz_read = h->bstr_read(h, tio_iobs[i].iob_buf,
443 		    tio_iobs[i].iob_total_size);
444 
445 		/*
446 		 * We need to read the source file into the buffer and make
447 		 * sure that the data in the buffer is a multiple of the
448 		 * blocksize (data or audio blocksize). this case should only
449 		 * be encountered at EOF or from piped input.
450 		 */
451 
452 		while ((rem = (sz_read % blksize)) != 0) {
453 			int ret;
454 
455 
456 			/*
457 			 * This should not occur, we are trying to write
458 			 * past the end of the buffer, return error.
459 			 */
460 
461 			if ((sz_read + (blksize - rem)) >
462 			    tio_iobs[i].iob_total_size) {
463 
464 				sz_read = -1;
465 				break;
466 			}
467 
468 			/*
469 			 * Try to continue reading in case the data is being
470 			 * piped in.
471 			 */
472 
473 			ret = h->bstr_read(h, &tio_iobs[i].iob_buf[sz_read],
474 			    (blksize - rem));
475 
476 			if (ret < 0) {
477 				sz_read = ret;
478 				break;
479 			}
480 
481 			/*
482 			 * No more data. We need to make sure that we are
483 			 * aligned with the blocksize. so pad the rest of
484 			 * the buffer with 0s
485 			 */
486 
487 			if (ret == 0) {
488 				/*
489 				 * rem contains the amount of data past the
490 				 * previous block boundry. we need to subtract
491 				 * it from the blocksize to get the amount
492 				 * needed to reach the next block boundry.
493 				 */
494 				ret = blksize - rem;
495 				(void) memset(&tio_iobs[i].iob_buf[sz_read],
496 				    0, ret);
497 			}
498 			sz_read += ret;
499 		}
500 		if (sz_read < 0) {
501 			te->err_type = TRACKIO_ERR_SYSTEM;
502 			te->te_errno = errno;
503 			goto write_track_failed;
504 		}
505 		(void) mutex_lock(&tio_mutex);
506 		tio_iobs[i].iob_start_blk = start_b;
507 		tio_iobs[i].iob_nblks = (sz_read/blksize);
508 		start_b += tio_iobs[i].iob_nblks;
509 		tio_iobs[i].iob_data_size = sz_read;
510 		tio_iobs[i].iob_state = IOBS_READY;
511 		(void) cond_broadcast(&tio_cond);
512 		(void) mutex_unlock(&tio_mutex);
513 		i++;
514 		if (i == NIOBS)
515 			i = 0;
516 	}
517 	(void) mutex_lock(&tio_mutex);
518 	while ((tio_errno == 0) && (tio_done == 0)) {
519 
520 		/* Wait for track IO to complete */
521 		(void) cond_wait(&tio_cond, &tio_mutex);
522 		if (tio_errno != 0) {
523 			te->err_type = TRACKIO_ERR_TRANSPORT;
524 			te->te_errno = tio_errno;
525 			te->status = uscsi_status;
526 			if (uscsi_status == 2) {
527 				te->key = SENSE_KEY(rqbuf) & 0xf;
528 				te->asc = ASC(rqbuf);
529 				te->ascq = ASCQ(rqbuf);
530 			}
531 			(void) mutex_unlock(&tio_mutex);
532 			goto write_track_failed;
533 		}
534 		if (cb != NULL) {
535 			while (tio_iobs[i].iob_state == IOBS_EMPTY) {
536 				(void) mutex_lock(&pcb_mutex);
537 				pcb_completed_io_size +=
538 				    tio_iobs[i].iob_data_size;
539 				(void) cond_broadcast(&pcb_cond);
540 				(void) mutex_unlock(&pcb_mutex);
541 				i++;
542 				if (i == NIOBS)
543 					i = 0;
544 			}
545 		}
546 	}
547 	(void) mutex_unlock(&tio_mutex);
548 	retval = 1;
549 write_track_failed:
550 	if (progress_callback_thr_created) {
551 		if (thr_kill(pc_thread, 0) == 0) {
552 			(void) mutex_lock(&pcb_mutex);
553 
554 			pcb_done = 1;
555 			(void) cond_broadcast(&pcb_cond);
556 			(void) mutex_unlock(&pcb_mutex);
557 			(void) thr_join(pc_thread, NULL, NULL);
558 		}
559 	}
560 	if (write_cd_thr_created) {
561 		if (thr_kill(tio_thread, 0) == 0) {
562 			(void) mutex_lock(&tio_mutex);
563 			tio_abort = 1;
564 			(void) cond_broadcast(&tio_cond);
565 			(void) mutex_unlock(&tio_mutex);
566 			(void) thr_join(tio_thread, NULL, NULL);
567 		}
568 	}
569 
570 	if (signal_handler_installed) {
571 		(void) signal(SIGINT, ohandler);
572 	}
573 
574 	fini_tio_data();
575 	fini_pcb_data();
576 	return (retval);
577 }
578