1 /* 2 * drivers/s390/char/tape_char.c 3 * character device frontend for tape device driver 4 * 5 * S390 and zSeries version 6 * Copyright IBM Corp. 2001,2006 7 * Author(s): Carsten Otte <cotte@de.ibm.com> 8 * Michael Holzheu <holzheu@de.ibm.com> 9 * Tuan Ngo-Anh <ngoanh@de.ibm.com> 10 * Martin Schwidefsky <schwidefsky@de.ibm.com> 11 */ 12 13 #include <linux/module.h> 14 #include <linux/types.h> 15 #include <linux/proc_fs.h> 16 #include <linux/mtio.h> 17 18 #include <asm/uaccess.h> 19 20 #define TAPE_DBF_AREA tape_core_dbf 21 22 #include "tape.h" 23 #include "tape_std.h" 24 #include "tape_class.h" 25 26 #define PRINTK_HEADER "TAPE_CHAR: " 27 28 #define TAPECHAR_MAJOR 0 /* get dynamic major */ 29 30 /* 31 * file operation structure for tape character frontend 32 */ 33 static ssize_t tapechar_read(struct file *, char __user *, size_t, loff_t *); 34 static ssize_t tapechar_write(struct file *, const char __user *, size_t, loff_t *); 35 static int tapechar_open(struct inode *,struct file *); 36 static int tapechar_release(struct inode *,struct file *); 37 static int tapechar_ioctl(struct inode *, struct file *, unsigned int, 38 unsigned long); 39 static long tapechar_compat_ioctl(struct file *, unsigned int, 40 unsigned long); 41 42 static const struct file_operations tape_fops = 43 { 44 .owner = THIS_MODULE, 45 .read = tapechar_read, 46 .write = tapechar_write, 47 .ioctl = tapechar_ioctl, 48 .compat_ioctl = tapechar_compat_ioctl, 49 .open = tapechar_open, 50 .release = tapechar_release, 51 }; 52 53 static int tapechar_major = TAPECHAR_MAJOR; 54 55 /* 56 * This function is called for every new tapedevice 57 */ 58 int 59 tapechar_setup_device(struct tape_device * device) 60 { 61 char device_name[20]; 62 63 sprintf(device_name, "ntibm%i", device->first_minor / 2); 64 device->nt = register_tape_dev( 65 &device->cdev->dev, 66 MKDEV(tapechar_major, device->first_minor), 67 &tape_fops, 68 device_name, 69 "non-rewinding" 70 ); 71 device_name[0] = 'r'; 72 device->rt = register_tape_dev( 73 &device->cdev->dev, 74 MKDEV(tapechar_major, device->first_minor + 1), 75 &tape_fops, 76 device_name, 77 "rewinding" 78 ); 79 80 return 0; 81 } 82 83 void 84 tapechar_cleanup_device(struct tape_device *device) 85 { 86 unregister_tape_dev(&device->cdev->dev, device->rt); 87 device->rt = NULL; 88 unregister_tape_dev(&device->cdev->dev, device->nt); 89 device->nt = NULL; 90 } 91 92 static int 93 tapechar_check_idalbuffer(struct tape_device *device, size_t block_size) 94 { 95 struct idal_buffer *new; 96 97 if (device->char_data.idal_buf != NULL && 98 device->char_data.idal_buf->size == block_size) 99 return 0; 100 101 if (block_size > MAX_BLOCKSIZE) { 102 DBF_EVENT(3, "Invalid blocksize (%zd > %d)\n", 103 block_size, MAX_BLOCKSIZE); 104 PRINT_ERR("Invalid blocksize (%zd> %d)\n", 105 block_size, MAX_BLOCKSIZE); 106 return -EINVAL; 107 } 108 109 /* The current idal buffer is not correct. Allocate a new one. */ 110 new = idal_buffer_alloc(block_size, 0); 111 if (new == NULL) 112 return -ENOMEM; 113 114 if (device->char_data.idal_buf != NULL) 115 idal_buffer_free(device->char_data.idal_buf); 116 117 device->char_data.idal_buf = new; 118 119 return 0; 120 } 121 122 /* 123 * Tape device read function 124 */ 125 static ssize_t 126 tapechar_read(struct file *filp, char __user *data, size_t count, loff_t *ppos) 127 { 128 struct tape_device *device; 129 struct tape_request *request; 130 size_t block_size; 131 int rc; 132 133 DBF_EVENT(6, "TCHAR:read\n"); 134 device = (struct tape_device *) filp->private_data; 135 136 /* 137 * If the tape isn't terminated yet, do it now. And since we then 138 * are at the end of the tape there wouldn't be anything to read 139 * anyways. So we return immediatly. 140 */ 141 if(device->required_tapemarks) { 142 return tape_std_terminate_write(device); 143 } 144 145 /* Find out block size to use */ 146 if (device->char_data.block_size != 0) { 147 if (count < device->char_data.block_size) { 148 DBF_EVENT(3, "TCHAR:read smaller than block " 149 "size was requested\n"); 150 return -EINVAL; 151 } 152 block_size = device->char_data.block_size; 153 } else { 154 block_size = count; 155 } 156 157 rc = tapechar_check_idalbuffer(device, block_size); 158 if (rc) 159 return rc; 160 161 #ifdef CONFIG_S390_TAPE_BLOCK 162 /* Changes position. */ 163 device->blk_data.medium_changed = 1; 164 #endif 165 166 DBF_EVENT(6, "TCHAR:nbytes: %lx\n", block_size); 167 /* Let the discipline build the ccw chain. */ 168 request = device->discipline->read_block(device, block_size); 169 if (IS_ERR(request)) 170 return PTR_ERR(request); 171 /* Execute it. */ 172 rc = tape_do_io(device, request); 173 if (rc == 0) { 174 rc = block_size - request->rescnt; 175 DBF_EVENT(6, "TCHAR:rbytes: %x\n", rc); 176 filp->f_pos += rc; 177 /* Copy data from idal buffer to user space. */ 178 if (idal_buffer_to_user(device->char_data.idal_buf, 179 data, rc) != 0) 180 rc = -EFAULT; 181 } 182 tape_free_request(request); 183 return rc; 184 } 185 186 /* 187 * Tape device write function 188 */ 189 static ssize_t 190 tapechar_write(struct file *filp, const char __user *data, size_t count, loff_t *ppos) 191 { 192 struct tape_device *device; 193 struct tape_request *request; 194 size_t block_size; 195 size_t written; 196 int nblocks; 197 int i, rc; 198 199 DBF_EVENT(6, "TCHAR:write\n"); 200 device = (struct tape_device *) filp->private_data; 201 /* Find out block size and number of blocks */ 202 if (device->char_data.block_size != 0) { 203 if (count < device->char_data.block_size) { 204 DBF_EVENT(3, "TCHAR:write smaller than block " 205 "size was requested\n"); 206 return -EINVAL; 207 } 208 block_size = device->char_data.block_size; 209 nblocks = count / block_size; 210 } else { 211 block_size = count; 212 nblocks = 1; 213 } 214 215 rc = tapechar_check_idalbuffer(device, block_size); 216 if (rc) 217 return rc; 218 219 #ifdef CONFIG_S390_TAPE_BLOCK 220 /* Changes position. */ 221 device->blk_data.medium_changed = 1; 222 #endif 223 224 DBF_EVENT(6,"TCHAR:nbytes: %lx\n", block_size); 225 DBF_EVENT(6, "TCHAR:nblocks: %x\n", nblocks); 226 /* Let the discipline build the ccw chain. */ 227 request = device->discipline->write_block(device, block_size); 228 if (IS_ERR(request)) 229 return PTR_ERR(request); 230 rc = 0; 231 written = 0; 232 for (i = 0; i < nblocks; i++) { 233 /* Copy data from user space to idal buffer. */ 234 if (idal_buffer_from_user(device->char_data.idal_buf, 235 data, block_size)) { 236 rc = -EFAULT; 237 break; 238 } 239 rc = tape_do_io(device, request); 240 if (rc) 241 break; 242 DBF_EVENT(6, "TCHAR:wbytes: %lx\n", 243 block_size - request->rescnt); 244 filp->f_pos += block_size - request->rescnt; 245 written += block_size - request->rescnt; 246 if (request->rescnt != 0) 247 break; 248 data += block_size; 249 } 250 tape_free_request(request); 251 if (rc == -ENOSPC) { 252 /* 253 * Ok, the device has no more space. It has NOT written 254 * the block. 255 */ 256 if (device->discipline->process_eov) 257 device->discipline->process_eov(device); 258 if (written > 0) 259 rc = 0; 260 261 } 262 263 /* 264 * After doing a write we always need two tapemarks to correctly 265 * terminate the tape (one to terminate the file, the second to 266 * flag the end of recorded data. 267 * Since process_eov positions the tape in front of the written 268 * tapemark it doesn't hurt to write two marks again. 269 */ 270 if (!rc) 271 device->required_tapemarks = 2; 272 273 return rc ? rc : written; 274 } 275 276 /* 277 * Character frontend tape device open function. 278 */ 279 static int 280 tapechar_open (struct inode *inode, struct file *filp) 281 { 282 struct tape_device *device; 283 int minor, rc; 284 285 DBF_EVENT(6, "TCHAR:open: %i:%i\n", 286 imajor(filp->f_path.dentry->d_inode), 287 iminor(filp->f_path.dentry->d_inode)); 288 289 if (imajor(filp->f_path.dentry->d_inode) != tapechar_major) 290 return -ENODEV; 291 292 minor = iminor(filp->f_path.dentry->d_inode); 293 device = tape_get_device(minor / TAPE_MINORS_PER_DEV); 294 if (IS_ERR(device)) { 295 DBF_EVENT(3, "TCHAR:open: tape_get_device() failed\n"); 296 return PTR_ERR(device); 297 } 298 299 300 rc = tape_open(device); 301 if (rc == 0) { 302 filp->private_data = device; 303 return nonseekable_open(inode, filp); 304 } 305 tape_put_device(device); 306 307 return rc; 308 } 309 310 /* 311 * Character frontend tape device release function. 312 */ 313 314 static int 315 tapechar_release(struct inode *inode, struct file *filp) 316 { 317 struct tape_device *device; 318 319 DBF_EVENT(6, "TCHAR:release: %x\n", iminor(inode)); 320 device = (struct tape_device *) filp->private_data; 321 322 /* 323 * If this is the rewinding tape minor then rewind. In that case we 324 * write all required tapemarks. Otherwise only one to terminate the 325 * file. 326 */ 327 if ((iminor(inode) & 1) != 0) { 328 if (device->required_tapemarks) 329 tape_std_terminate_write(device); 330 tape_mtop(device, MTREW, 1); 331 } else { 332 if (device->required_tapemarks > 1) { 333 if (tape_mtop(device, MTWEOF, 1) == 0) 334 device->required_tapemarks--; 335 } 336 } 337 338 if (device->char_data.idal_buf != NULL) { 339 idal_buffer_free(device->char_data.idal_buf); 340 device->char_data.idal_buf = NULL; 341 } 342 tape_release(device); 343 filp->private_data = tape_put_device(device); 344 345 return 0; 346 } 347 348 /* 349 * Tape device io controls. 350 */ 351 static int 352 tapechar_ioctl(struct inode *inp, struct file *filp, 353 unsigned int no, unsigned long data) 354 { 355 struct tape_device *device; 356 int rc; 357 358 DBF_EVENT(6, "TCHAR:ioct\n"); 359 360 device = (struct tape_device *) filp->private_data; 361 362 if (no == MTIOCTOP) { 363 struct mtop op; 364 365 if (copy_from_user(&op, (char __user *) data, sizeof(op)) != 0) 366 return -EFAULT; 367 if (op.mt_count < 0) 368 return -EINVAL; 369 370 /* 371 * Operations that change tape position should write final 372 * tapemarks. 373 */ 374 switch (op.mt_op) { 375 case MTFSF: 376 case MTBSF: 377 case MTFSR: 378 case MTBSR: 379 case MTREW: 380 case MTOFFL: 381 case MTEOM: 382 case MTRETEN: 383 case MTBSFM: 384 case MTFSFM: 385 case MTSEEK: 386 #ifdef CONFIG_S390_TAPE_BLOCK 387 device->blk_data.medium_changed = 1; 388 #endif 389 if (device->required_tapemarks) 390 tape_std_terminate_write(device); 391 default: 392 ; 393 } 394 rc = tape_mtop(device, op.mt_op, op.mt_count); 395 396 if (op.mt_op == MTWEOF && rc == 0) { 397 if (op.mt_count > device->required_tapemarks) 398 device->required_tapemarks = 0; 399 else 400 device->required_tapemarks -= op.mt_count; 401 } 402 return rc; 403 } 404 if (no == MTIOCPOS) { 405 /* MTIOCPOS: query the tape position. */ 406 struct mtpos pos; 407 408 rc = tape_mtop(device, MTTELL, 1); 409 if (rc < 0) 410 return rc; 411 pos.mt_blkno = rc; 412 if (copy_to_user((char __user *) data, &pos, sizeof(pos)) != 0) 413 return -EFAULT; 414 return 0; 415 } 416 if (no == MTIOCGET) { 417 /* MTIOCGET: query the tape drive status. */ 418 struct mtget get; 419 420 memset(&get, 0, sizeof(get)); 421 get.mt_type = MT_ISUNKNOWN; 422 get.mt_resid = 0 /* device->devstat.rescnt */; 423 get.mt_dsreg = device->tape_state; 424 /* FIXME: mt_gstat, mt_erreg, mt_fileno */ 425 get.mt_gstat = 0; 426 get.mt_erreg = 0; 427 get.mt_fileno = 0; 428 get.mt_gstat = device->tape_generic_status; 429 430 if (device->medium_state == MS_LOADED) { 431 rc = tape_mtop(device, MTTELL, 1); 432 433 if (rc < 0) 434 return rc; 435 436 if (rc == 0) 437 get.mt_gstat |= GMT_BOT(~0); 438 439 get.mt_blkno = rc; 440 } 441 442 if (copy_to_user((char __user *) data, &get, sizeof(get)) != 0) 443 return -EFAULT; 444 445 return 0; 446 } 447 /* Try the discipline ioctl function. */ 448 if (device->discipline->ioctl_fn == NULL) 449 return -EINVAL; 450 return device->discipline->ioctl_fn(device, no, data); 451 } 452 453 static long 454 tapechar_compat_ioctl(struct file *filp, unsigned int no, unsigned long data) 455 { 456 struct tape_device *device = filp->private_data; 457 int rval = -ENOIOCTLCMD; 458 459 if (device->discipline->ioctl_fn) { 460 lock_kernel(); 461 rval = device->discipline->ioctl_fn(device, no, data); 462 unlock_kernel(); 463 if (rval == -EINVAL) 464 rval = -ENOIOCTLCMD; 465 } 466 467 return rval; 468 } 469 470 /* 471 * Initialize character device frontend. 472 */ 473 int 474 tapechar_init (void) 475 { 476 dev_t dev; 477 478 if (alloc_chrdev_region(&dev, 0, 256, "tape") != 0) 479 return -1; 480 481 tapechar_major = MAJOR(dev); 482 PRINT_INFO("tape gets major %d for character devices\n", MAJOR(dev)); 483 484 return 0; 485 } 486 487 /* 488 * cleanup 489 */ 490 void 491 tapechar_exit(void) 492 { 493 PRINT_INFO("tape releases major %d for character devices\n", 494 tapechar_major); 495 unregister_chrdev_region(MKDEV(tapechar_major, 0), 256); 496 } 497