Merge branch 'for-linus' of git://git390.marist.edu/pub/scm/linux-2.6

+1 -1

arch/s390/crypto/prng.c

··· 76 76 77 77 /* Add the entropy */ 78 78 while (nbytes >= 8) { 79 - *((__u64 *)parm_block) ^= *((__u64 *)buf+i*8); 79 + *((__u64 *)parm_block) ^= *((__u64 *)buf+i); 80 80 prng_add_entropy(); 81 81 i += 8; 82 82 nbytes -= 8;

+2 -2

arch/s390/kvm/sie64a.S

··· 48 48 tm __TI_flags+7(%r2),_TIF_EXIT_SIE 49 49 jz 0f 50 50 larl %r2,sie_exit # work pending, leave sie 51 - stg %r2,__LC_RETURN_PSW+8 51 + stg %r2,SPI_PSW+8(0,%r15) 52 52 br %r14 53 53 0: larl %r2,sie_reenter # re-enter with guest id 54 - stg %r2,__LC_RETURN_PSW+8 54 + stg %r2,SPI_PSW+8(0,%r15) 55 55 1: br %r14 56 56 57 57 /*

+2 -2

arch/s390/mm/fault.c

··· 558 558 * Get the token (= address of the task structure of the affected task). 559 559 */ 560 560 #ifdef CONFIG_64BIT 561 - tsk = *(struct task_struct **) param64; 561 + tsk = (struct task_struct *) param64; 562 562 #else 563 - tsk = *(struct task_struct **) param32; 563 + tsk = (struct task_struct *) param32; 564 564 #endif 565 565 566 566 if (subcode & 0x0080) {

+3 -2

arch/s390/mm/pageattr.c

··· 24 24 WARN_ON_ONCE(1); 25 25 continue; 26 26 } 27 - ptep = pte_offset_kernel(pmdp, addr + i * PAGE_SIZE); 27 + ptep = pte_offset_kernel(pmdp, addr); 28 28 29 29 pte = *ptep; 30 30 pte = set(pte); 31 - ptep_invalidate(&init_mm, addr + i * PAGE_SIZE, ptep); 31 + ptep_invalidate(&init_mm, addr, ptep); 32 32 *ptep = pte; 33 + addr += PAGE_SIZE; 33 34 } 34 35 } 35 36

+22 -18

drivers/s390/block/dasd.c

··· 2314 2314 2315 2315 static int dasd_open(struct block_device *bdev, fmode_t mode) 2316 2316 { 2317 - struct dasd_block *block = bdev->bd_disk->private_data; 2318 2317 struct dasd_device *base; 2319 2318 int rc; 2320 2319 2321 - if (!block) 2320 + base = dasd_device_from_gendisk(bdev->bd_disk); 2321 + if (!base) 2322 2322 return -ENODEV; 2323 2323 2324 - base = block->base; 2325 - atomic_inc(&block->open_count); 2324 + atomic_inc(&base->block->open_count); 2326 2325 if (test_bit(DASD_FLAG_OFFLINE, &base->flags)) { 2327 2326 rc = -ENODEV; 2328 2327 goto unlock; ··· 2354 2355 goto out; 2355 2356 } 2356 2357 2358 + dasd_put_device(base); 2357 2359 return 0; 2358 2360 2359 2361 out: 2360 2362 module_put(base->discipline->owner); 2361 2363 unlock: 2362 - atomic_dec(&block->open_count); 2364 + atomic_dec(&base->block->open_count); 2365 + dasd_put_device(base); 2363 2366 return rc; 2364 2367 } 2365 2368 2366 2369 static int dasd_release(struct gendisk *disk, fmode_t mode) 2367 2370 { 2368 - struct dasd_block *block = disk->private_data; 2371 + struct dasd_device *base; 2369 2372 2370 - atomic_dec(&block->open_count); 2371 - module_put(block->base->discipline->owner); 2373 + base = dasd_device_from_gendisk(disk); 2374 + if (!base) 2375 + return -ENODEV; 2376 + 2377 + atomic_dec(&base->block->open_count); 2378 + module_put(base->discipline->owner); 2379 + dasd_put_device(base); 2372 2380 return 0; 2373 2381 } 2374 2382 ··· 2384 2378 */ 2385 2379 static int dasd_getgeo(struct block_device *bdev, struct hd_geometry *geo) 2386 2380 { 2387 - struct dasd_block *block; 2388 2381 struct dasd_device *base; 2389 2382 2390 - block = bdev->bd_disk->private_data; 2391 - if (!block) 2383 + base = dasd_device_from_gendisk(bdev->bd_disk); 2384 + if (!base) 2392 2385 return -ENODEV; 2393 - base = block->base; 2394 2386 2395 2387 if (!base->discipline || 2396 - !base->discipline->fill_geometry) 2388 + !base->discipline->fill_geometry) { 2389 + dasd_put_device(base); 2397 2390 return -EINVAL; 2398 - 2399 - base->discipline->fill_geometry(block, geo); 2400 - geo->start = get_start_sect(bdev) >> block->s2b_shift; 2391 + } 2392 + base->discipline->fill_geometry(base->block, geo); 2393 + geo->start = get_start_sect(bdev) >> base->block->s2b_shift; 2394 + dasd_put_device(base); 2401 2395 return 0; 2402 2396 } 2403 2397 ··· 2534 2528 dasd_set_target_state(device, DASD_STATE_NEW); 2535 2529 /* dasd_delete_device destroys the device reference. */ 2536 2530 block = device->block; 2537 - device->block = NULL; 2538 2531 dasd_delete_device(device); 2539 2532 /* 2540 2533 * life cycle of block is bound to device, so delete it after ··· 2655 2650 dasd_set_target_state(device, DASD_STATE_NEW); 2656 2651 /* dasd_delete_device destroys the device reference. */ 2657 2652 block = device->block; 2658 - device->block = NULL; 2659 2653 dasd_delete_device(device); 2660 2654 /* 2661 2655 * life cycle of block is bound to device, so delete it after

+30

drivers/s390/block/dasd_devmap.c

··· 674 674 return device; 675 675 } 676 676 677 + void dasd_add_link_to_gendisk(struct gendisk *gdp, struct dasd_device *device) 678 + { 679 + struct dasd_devmap *devmap; 680 + 681 + devmap = dasd_find_busid(dev_name(&device->cdev->dev)); 682 + if (IS_ERR(devmap)) 683 + return; 684 + spin_lock(&dasd_devmap_lock); 685 + gdp->private_data = devmap; 686 + spin_unlock(&dasd_devmap_lock); 687 + } 688 + 689 + struct dasd_device *dasd_device_from_gendisk(struct gendisk *gdp) 690 + { 691 + struct dasd_device *device; 692 + struct dasd_devmap *devmap; 693 + 694 + if (!gdp->private_data) 695 + return NULL; 696 + device = NULL; 697 + spin_lock(&dasd_devmap_lock); 698 + devmap = gdp->private_data; 699 + if (devmap && devmap->device) { 700 + device = devmap->device; 701 + dasd_get_device(device); 702 + } 703 + spin_unlock(&dasd_devmap_lock); 704 + return device; 705 + } 706 + 677 707 /* 678 708 * SECTION: files in sysfs 679 709 */

+3 -2

drivers/s390/block/dasd_eckd.c

··· 2037 2037 return; 2038 2038 2039 2039 /* summary unit check */ 2040 - if ((sense[7] == 0x0D) && 2040 + if ((sense[27] & DASD_SENSE_BIT_0) && (sense[7] == 0x0D) && 2041 2041 (scsw_dstat(&irb->scsw) & DEV_STAT_UNIT_CHECK)) { 2042 2042 dasd_alias_handle_summary_unit_check(device, irb); 2043 2043 return; ··· 2053 2053 /* loss of device reservation is handled via base devices only 2054 2054 * as alias devices may be used with several bases 2055 2055 */ 2056 - if (device->block && (sense[7] == 0x3F) && 2056 + if (device->block && (sense[27] & DASD_SENSE_BIT_0) && 2057 + (sense[7] == 0x3F) && 2057 2058 (scsw_dstat(&irb->scsw) & DEV_STAT_UNIT_CHECK) && 2058 2059 test_bit(DASD_FLAG_IS_RESERVED, &device->flags)) { 2059 2060 if (device->features & DASD_FEATURE_FAILONSLCK)

+1 -1

drivers/s390/block/dasd_genhd.c

··· 73 73 if (base->features & DASD_FEATURE_READONLY || 74 74 test_bit(DASD_FLAG_DEVICE_RO, &base->flags)) 75 75 set_disk_ro(gdp, 1); 76 - gdp->private_data = block; 76 + dasd_add_link_to_gendisk(gdp, base); 77 77 gdp->queue = block->request_queue; 78 78 block->gdp = gdp; 79 79 set_capacity(block->gdp, 0);

+3

drivers/s390/block/dasd_int.h

··· 686 686 struct dasd_device *dasd_device_from_cdev_locked(struct ccw_device *); 687 687 struct dasd_device *dasd_device_from_devindex(int); 688 688 689 + void dasd_add_link_to_gendisk(struct gendisk *, struct dasd_device *); 690 + struct dasd_device *dasd_device_from_gendisk(struct gendisk *); 691 + 689 692 int dasd_parse(void); 690 693 int dasd_busid_known(const char *); 691 694

+87 -41

drivers/s390/block/dasd_ioctl.c

··· 42 42 static int 43 43 dasd_ioctl_enable(struct block_device *bdev) 44 44 { 45 - struct dasd_block *block = bdev->bd_disk->private_data; 45 + struct dasd_device *base; 46 46 47 47 if (!capable(CAP_SYS_ADMIN)) 48 48 return -EACCES; 49 49 50 - dasd_enable_device(block->base); 50 + base = dasd_device_from_gendisk(bdev->bd_disk); 51 + if (!base) 52 + return -ENODEV; 53 + 54 + dasd_enable_device(base); 51 55 /* Formatting the dasd device can change the capacity. */ 52 56 mutex_lock(&bdev->bd_mutex); 53 - i_size_write(bdev->bd_inode, (loff_t)get_capacity(block->gdp) << 9); 57 + i_size_write(bdev->bd_inode, 58 + (loff_t)get_capacity(base->block->gdp) << 9); 54 59 mutex_unlock(&bdev->bd_mutex); 60 + dasd_put_device(base); 55 61 return 0; 56 62 } 57 63 ··· 68 62 static int 69 63 dasd_ioctl_disable(struct block_device *bdev) 70 64 { 71 - struct dasd_block *block = bdev->bd_disk->private_data; 65 + struct dasd_device *base; 72 66 73 67 if (!capable(CAP_SYS_ADMIN)) 74 68 return -EACCES; 75 69 70 + base = dasd_device_from_gendisk(bdev->bd_disk); 71 + if (!base) 72 + return -ENODEV; 76 73 /* 77 74 * Man this is sick. We don't do a real disable but only downgrade 78 75 * the device to DASD_STATE_BASIC. The reason is that dasdfmt uses ··· 84 75 * using the BIODASDFMT ioctl. Therefore the correct state for the 85 76 * device is DASD_STATE_BASIC that allows to do basic i/o. 86 77 */ 87 - dasd_set_target_state(block->base, DASD_STATE_BASIC); 78 + dasd_set_target_state(base, DASD_STATE_BASIC); 88 79 /* 89 80 * Set i_size to zero, since read, write, etc. check against this 90 81 * value. ··· 92 83 mutex_lock(&bdev->bd_mutex); 93 84 i_size_write(bdev->bd_inode, 0); 94 85 mutex_unlock(&bdev->bd_mutex); 86 + dasd_put_device(base); 95 87 return 0; 96 88 } 97 89 ··· 201 191 static int 202 192 dasd_ioctl_format(struct block_device *bdev, void __user *argp) 203 193 { 204 - struct dasd_block *block = bdev->bd_disk->private_data; 194 + struct dasd_device *base; 205 195 struct format_data_t fdata; 196 + int rc; 206 197 207 198 if (!capable(CAP_SYS_ADMIN)) 208 199 return -EACCES; 209 200 if (!argp) 210 201 return -EINVAL; 211 - 212 - if (block->base->features & DASD_FEATURE_READONLY || 213 - test_bit(DASD_FLAG_DEVICE_RO, &block->base->flags)) 202 + base = dasd_device_from_gendisk(bdev->bd_disk); 203 + if (!base) 204 + return -ENODEV; 205 + if (base->features & DASD_FEATURE_READONLY || 206 + test_bit(DASD_FLAG_DEVICE_RO, &base->flags)) { 207 + dasd_put_device(base); 214 208 return -EROFS; 215 - if (copy_from_user(&fdata, argp, sizeof(struct format_data_t))) 209 + } 210 + if (copy_from_user(&fdata, argp, sizeof(struct format_data_t))) { 211 + dasd_put_device(base); 216 212 return -EFAULT; 213 + } 217 214 if (bdev != bdev->bd_contains) { 218 215 pr_warning("%s: The specified DASD is a partition and cannot " 219 216 "be formatted\n", 220 - dev_name(&block->base->cdev->dev)); 217 + dev_name(&base->cdev->dev)); 218 + dasd_put_device(base); 221 219 return -EINVAL; 222 220 } 223 - return dasd_format(block, &fdata); 221 + rc = dasd_format(base->block, &fdata); 222 + dasd_put_device(base); 223 + return rc; 224 224 } 225 225 226 226 #ifdef CONFIG_DASD_PROFILE ··· 360 340 static int 361 341 dasd_ioctl_set_ro(struct block_device *bdev, void __user *argp) 362 342 { 363 - struct dasd_block *block = bdev->bd_disk->private_data; 364 - int intval; 343 + struct dasd_device *base; 344 + int intval, rc; 365 345 366 346 if (!capable(CAP_SYS_ADMIN)) 367 347 return -EACCES; ··· 370 350 return -EINVAL; 371 351 if (get_user(intval, (int __user *)argp)) 372 352 return -EFAULT; 373 - if (!intval && test_bit(DASD_FLAG_DEVICE_RO, &block->base->flags)) 353 + base = dasd_device_from_gendisk(bdev->bd_disk); 354 + if (!base) 355 + return -ENODEV; 356 + if (!intval && test_bit(DASD_FLAG_DEVICE_RO, &base->flags)) { 357 + dasd_put_device(base); 374 358 return -EROFS; 359 + } 375 360 set_disk_ro(bdev->bd_disk, intval); 376 - return dasd_set_feature(block->base->cdev, DASD_FEATURE_READONLY, intval); 361 + rc = dasd_set_feature(base->cdev, DASD_FEATURE_READONLY, intval); 362 + dasd_put_device(base); 363 + return rc; 377 364 } 378 365 379 366 static int dasd_ioctl_readall_cmb(struct dasd_block *block, unsigned int cmd, ··· 399 372 int dasd_ioctl(struct block_device *bdev, fmode_t mode, 400 373 unsigned int cmd, unsigned long arg) 401 374 { 402 - struct dasd_block *block = bdev->bd_disk->private_data; 375 + struct dasd_block *block; 376 + struct dasd_device *base; 403 377 void __user *argp; 378 + int rc; 404 379 405 380 if (is_compat_task()) 406 381 argp = compat_ptr(arg); 407 382 else 408 383 argp = (void __user *)arg; 409 384 410 - if (!block) 411 - return -ENODEV; 412 - 413 385 if ((_IOC_DIR(cmd) != _IOC_NONE) && !arg) { 414 386 PRINT_DEBUG("empty data ptr"); 415 387 return -EINVAL; 416 388 } 417 389 390 + base = dasd_device_from_gendisk(bdev->bd_disk); 391 + if (!base) 392 + return -ENODEV; 393 + block = base->block; 394 + rc = 0; 418 395 switch (cmd) { 419 396 case BIODASDDISABLE: 420 - return dasd_ioctl_disable(bdev); 397 + rc = dasd_ioctl_disable(bdev); 398 + break; 421 399 case BIODASDENABLE: 422 - return dasd_ioctl_enable(bdev); 400 + rc = dasd_ioctl_enable(bdev); 401 + break; 423 402 case BIODASDQUIESCE: 424 - return dasd_ioctl_quiesce(block); 403 + rc = dasd_ioctl_quiesce(block); 404 + break; 425 405 case BIODASDRESUME: 426 - return dasd_ioctl_resume(block); 406 + rc = dasd_ioctl_resume(block); 407 + break; 427 408 case BIODASDFMT: 428 - return dasd_ioctl_format(bdev, argp); 409 + rc = dasd_ioctl_format(bdev, argp); 410 + break; 429 411 case BIODASDINFO: 430 - return dasd_ioctl_information(block, cmd, argp); 412 + rc = dasd_ioctl_information(block, cmd, argp); 413 + break; 431 414 case BIODASDINFO2: 432 - return dasd_ioctl_information(block, cmd, argp); 415 + rc = dasd_ioctl_information(block, cmd, argp); 416 + break; 433 417 case BIODASDPRRD: 434 - return dasd_ioctl_read_profile(block, argp); 418 + rc = dasd_ioctl_read_profile(block, argp); 419 + break; 435 420 case BIODASDPRRST: 436 - return dasd_ioctl_reset_profile(block); 421 + rc = dasd_ioctl_reset_profile(block); 422 + break; 437 423 case BLKROSET: 438 - return dasd_ioctl_set_ro(bdev, argp); 424 + rc = dasd_ioctl_set_ro(bdev, argp); 425 + break; 439 426 case DASDAPIVER: 440 - return dasd_ioctl_api_version(argp); 427 + rc = dasd_ioctl_api_version(argp); 428 + break; 441 429 case BIODASDCMFENABLE: 442 - return enable_cmf(block->base->cdev); 430 + rc = enable_cmf(base->cdev); 431 + break; 443 432 case BIODASDCMFDISABLE: 444 - return disable_cmf(block->base->cdev); 433 + rc = disable_cmf(base->cdev); 434 + break; 445 435 case BIODASDREADALLCMB: 446 - return dasd_ioctl_readall_cmb(block, cmd, argp); 436 + rc = dasd_ioctl_readall_cmb(block, cmd, argp); 437 + break; 447 438 default: 448 439 /* if the discipline has an ioctl method try it. */ 449 - if (block->base->discipline->ioctl) { 450 - int rval = block->base->discipline->ioctl(block, cmd, argp); 451 - if (rval != -ENOIOCTLCMD) 452 - return rval; 453 - } 454 - 455 - return -EINVAL; 440 + if (base->discipline->ioctl) { 441 + rc = base->discipline->ioctl(block, cmd, argp); 442 + if (rc == -ENOIOCTLCMD) 443 + rc = -EINVAL; 444 + } else 445 + rc = -EINVAL; 456 446 } 447 + dasd_put_device(base); 448 + return rc; 457 449 }

+12 -5

drivers/s390/cio/qdio_main.c

··· 407 407 q->q_stats.nr_sbals[pos]++; 408 408 } 409 409 410 - static void announce_buffer_error(struct qdio_q *q, int count) 410 + static void process_buffer_error(struct qdio_q *q, int count) 411 411 { 412 + unsigned char state = (q->is_input_q) ? SLSB_P_INPUT_NOT_INIT : 413 + SLSB_P_OUTPUT_NOT_INIT; 414 + 412 415 q->qdio_error |= QDIO_ERROR_SLSB_STATE; 413 416 414 417 /* special handling for no target buffer empty */ ··· 429 426 DBF_ERROR("F14:%2x F15:%2x", 430 427 q->sbal[q->first_to_check]->element[14].flags & 0xff, 431 428 q->sbal[q->first_to_check]->element[15].flags & 0xff); 429 + 430 + /* 431 + * Interrupts may be avoided as long as the error is present 432 + * so change the buffer state immediately to avoid starvation. 433 + */ 434 + set_buf_states(q, q->first_to_check, state, count); 432 435 } 433 436 434 437 static inline void inbound_primed(struct qdio_q *q, int count) ··· 515 506 account_sbals(q, count); 516 507 break; 517 508 case SLSB_P_INPUT_ERROR: 518 - announce_buffer_error(q, count); 519 - /* process the buffer, the upper layer will take care of it */ 509 + process_buffer_error(q, count); 520 510 q->first_to_check = add_buf(q->first_to_check, count); 521 511 atomic_sub(count, &q->nr_buf_used); 522 512 if (q->irq_ptr->perf_stat_enabled) ··· 685 677 account_sbals(q, count); 686 678 break; 687 679 case SLSB_P_OUTPUT_ERROR: 688 - announce_buffer_error(q, count); 689 - /* process the buffer, the upper layer will take care of it */ 680 + process_buffer_error(q, count); 690 681 q->first_to_check = add_buf(q->first_to_check, count); 691 682 atomic_sub(count, &q->nr_buf_used); 692 683 if (q->irq_ptr->perf_stat_enabled)

Configure Feed

Configure Feed