litmus-rt.git - The LITMUS^RT kernel.

diff options

author	Al Viro <viro@ftp.linux.org.uk>	2006-09-23 11:44:58 -0400
committer	Linus Torvalds <torvalds@g5.osdl.org>	2006-09-23 14:34:43 -0400
commit	13b5aeccc4350e5069c723e8f9becd7208ee02f2 (patch)
tree	84decf7505e98d2e1d7a0935219f8b5e006c04d7 /arch
parent	d7b2004528a967f2ba0bf31b1eb0da6a876960e6 (diff)

[PATCH] more fallout from get_property returning pointer to const

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk> Signed-off-by: Linus Torvalds <torvalds@osdl.org>

Diffstat (limited to 'arch')

-rw-r--r--

arch/powerpc/platforms/powermac/feature.c

-rw-r--r--

arch/powerpc/platforms/powermac/smp.c

2 files changed, 3 insertions, 3 deletions


diff --git a/arch/powerpc/platforms/powermac/feature.c b/arch/powerpc/platforms/powermac/feature.c index 13fcaf5b1796..e49621be6640 100644 --- a/arch/powerpc/platforms/powermac/feature.c +++ b/arch/powerpc/platforms/powermac/feature.c
@@ -1058,8 +1058,8 @@ core99_reset_cpu(struct device_node *node, long param, long value)
1058	if (np == NULL)	1058	if (np == NULL)
1059	return -ENODEV;	1059	return -ENODEV;
1060	for (np = np->child; np != NULL; np = np->sibling) {	1060	for (np = np->child; np != NULL; np = np->sibling) {
1061	u32 *num = get_property(np, "reg", NULL);	1061	const u32 *num = get_property(np, "reg", NULL);
1062	u32 *rst = get_property(np, "soft-reset", NULL);	1062	const u32 *rst = get_property(np, "soft-reset", NULL);
1063	if (num == NULL \|\| rst == NULL)	1063	if (num == NULL \|\| rst == NULL)
1064	continue;	1064	continue;
1065	if (param == *num) {	1065	if (param == *num) {


diff --git a/arch/powerpc/platforms/powermac/smp.c b/arch/powerpc/platforms/powermac/smp.c index 653eeb64d1e2..1949b657b092 100644 --- a/arch/powerpc/platforms/powermac/smp.c +++ b/arch/powerpc/platforms/powermac/smp.c
@@ -702,7 +702,7 @@ static void __init smp_core99_setup(int ncpus)
702	/* GPIO based HW sync on ppc32 Core99 */	702	/* GPIO based HW sync on ppc32 Core99 */
703	if (pmac_tb_freeze == NULL && !machine_is_compatible("MacRISC4")) {	703	if (pmac_tb_freeze == NULL && !machine_is_compatible("MacRISC4")) {
704	struct device_node *cpu;	704	struct device_node *cpu;
705	u32 *tbprop = NULL;	705	const u32 *tbprop = NULL;
706		706
707	core99_tb_gpio = KL_GPIO_TB_ENABLE; /* default value */	707	core99_tb_gpio = KL_GPIO_TB_ENABLE; /* default value */
708	cpu = of_find_node_by_type(NULL, "cpu");	708	cpu = of_find_node_by_type(NULL, "cpu");

110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234

380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437

502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586

/* * Copyright (C) 2001, 2002 Sistina Software (UK) Limited. * Copyright (C) 2004 Red Hat, Inc. All rights reserved. * * This file is released under the GPL. */ #include "dm.h" #include "dm-bio-list.h" #include <linux/init.h> #include <linux/module.h> #include <linux/mutex.h> #include <linux/moduleparam.h> #include <linux/blkpg.h> #include <linux/bio.h> #include <linux/buffer_head.h> #include <linux/mempool.h> #include <linux/slab.h> #include <linux/idr.h> #include <linux/hdreg.h> #include <linux/blktrace_api.h> static const char *_name = DM_NAME; static unsigned int major = 0; static unsigned int _major = 0; /* * One of these is allocated per bio. */ struct dm_io { struct mapped_device *md; int error; struct bio *bio; atomic_t io_count; unsigned long start_time; }; /* * One of these is allocated per target within a bio. Hopefully * this will be simplified out one day. */ struct target_io { struct dm_io *io; struct dm_target *ti; union map_info info; }; union map_info *dm_get_mapinfo(struct bio *bio) { if (bio && bio->bi_private) return &((struct target_io *)bio->bi_private)->info; return NULL; } /* * Bits for the md->flags field. */ #define DMF_BLOCK_IO 0 #define DMF_SUSPENDED 1 #define DMF_FROZEN 2 struct mapped_device { struct rw_semaphore io_lock; struct semaphore suspend_lock; rwlock_t map_lock; atomic_t holders; unsigned long flags; request_queue_t *queue; struct gendisk *disk; char name[16]; void *interface_ptr; /* * A list of ios that arrived while we were suspended. */ atomic_t pending; wait_queue_head_t wait; struct bio_list deferred; /* * The current mapping. */ struct dm_table *map; /* * io objects are allocated from here. */ mempool_t *io_pool; mempool_t *tio_pool; /* * Event handling. */ atomic_t event_nr; wait_queue_head_t eventq; /* * freeze/thaw support require holding onto a super block */ struct super_block *frozen_sb; struct block_device *suspended_bdev; /* forced geometry settings */ struct hd_geometry geometry; }; #define MIN_IOS 256 static kmem_cache_t *_io_cache; static kmem_cache_t *_tio_cache; static struct bio_set *dm_set; static int __init local_init(void) { int r; dm_set = bioset_create(16, 16, 4); if (!dm_set) return -ENOMEM; /* allocate a slab for the dm_ios */ _io_cache = kmem_cache_create("dm_io", sizeof(struct dm_io), 0, 0, NULL, NULL); if (!_io_cache) return -ENOMEM; /* allocate a slab for the target ios */ _tio_cache = kmem_cache_create("dm_tio", sizeof(struct target_io), 0, 0, NULL, NULL); if (!_tio_cache) { kmem_cache_destroy(_io_cache); return -ENOMEM; } _major = major; r = register_blkdev(_major, _name); if (r < 0) { kmem_cache_destroy(_tio_cache); kmem_cache_destroy(_io_cache); return r; } if (!_major) _major = r; return 0; } static void local_exit(void) { kmem_cache_destroy(_tio_cache); kmem_cache_destroy(_io_cache); bioset_free(dm_set); if (unregister_blkdev(_major, _name) < 0) DMERR("devfs_unregister_blkdev failed"); _major = 0; DMINFO("cleaned up"); } int (*_inits[])(void) __initdata = { local_init, dm_target_init, dm_linear_init, dm_stripe_init, dm_interface_init, }; void (*_exits[])(void) = { local_exit, dm_target_exit, dm_linear_exit, dm_stripe_exit, dm_interface_exit, }; static int __init dm_init(void) { const int count = ARRAY_SIZE(_inits); int r, i; for (i = 0; i < count; i++) { r = _inits[i](); if (r) goto bad; } return 0; bad: while (i--) _exits[i](); return r; } static void __exit dm_exit(void) { int i = ARRAY_SIZE(_exits); while (i--) _exits[i](); } /* * Block device functions */ static int dm_blk_open(struct inode *inode, struct file *file) { struct mapped_device *md; md = inode->i_bdev->bd_disk->private_data; dm_get(md); return 0; } static int dm_blk_close(struct inode *inode, struct file *file) { struct mapped_device *md; md = inode->i_bdev->bd_disk->private_data; dm_put(md); return 0; } static int dm_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo) { struct mapped_device *md = bdev->bd_disk->private_data; return dm_get_geometry(md, geo); } static inline struct dm_io *alloc_io(struct mapped_device *md) { return mempool_alloc(md->io_pool, GFP_NOIO); } static inline void free_io(struct mapped_device *md, struct dm_io *io) { mempool_free(io, md->io_pool); } static inline struct target_io *alloc_tio(struct mapped_device *md) { return mempool_alloc(md->tio_pool, GFP_NOIO); } static inline void free_tio(struct mapped_device *md, struct target_io *tio) { mempool_free(tio, md->tio_pool); } static void start_io_acct(struct dm_io *io) { struct mapped_device *md = io->md; io->start_time = jiffies; preempt_disable(); disk_round_stats(dm_disk(md)); preempt_enable(); dm_disk(md)->in_flight = atomic_inc_return(&md->pending); } static int end_io_acct(struct dm_io *io) { struct mapped_device *md = io->md; struct bio *bio = io->bio; unsigned long duration = jiffies - io->start_time; int pending; int rw = bio_data_dir(bio); preempt_disable(); disk_round_stats(dm_disk(md)); preempt_enable(); dm_disk(md)->in_flight = pending = atomic_dec_return(&md->pending); disk_stat_add(dm_disk(md), ticks[rw], duration); return !pending; } /* * Add the bio to the list of deferred io. */ static int queue_io(struct mapped_device *md, struct bio *bio) { down_write(&md->io_lock); if (!test_bit(DMF_BLOCK_IO, &md->flags)) { up_write(&md->io_lock); return 1; } bio_list_add(&md->deferred, bio); up_write(&md->io_lock); return 0; /* deferred successfully */ } /* * Everyone (including functions in this file), should use this * function to access the md->map field, and make sure they call * dm_table_put() when finished. */ struct dm_table *dm_get_table(struct mapped_device *md) { struct dm_table *t; read_lock(&md->map_lock); t = md->map; if (t) dm_table_get(t); read_unlock(&md->map_lock); return t; } /* * Get the geometry associated with a dm device */ int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo) { *geo = md->geometry; return 0; } /* * Set the geometry of a device. */ int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo) { sector_t sz = (sector_t)geo->cylinders * geo->heads * geo->sectors; if (geo->start > sz) { DMWARN("Start sector is beyond the geometry limits."); return -EINVAL; } md->geometry = *geo; return 0; } /*----------------------------------------------------------------- * CRUD START: * A more elegant soln is in the works that uses the queue * merge fn, unfortunately there are a couple of changes to * the block layer that I want to make for this. So in the * interests of getting something for people to use I give * you this clearly demarcated crap. *---------------------------------------------------------------*/ /* * Decrements the number of outstanding ios that a bio has been * cloned into, completing the original io if necc. */ static void dec_pending(struct dm_io *io, int error) { if (error) io->error = error; if (atomic_dec_and_test(&io->io_count)) { if (end_io_acct(io)) /* nudge anyone waiting on suspend queue */ wake_up(&io->md->wait); blk_add_trace_bio(io->md->queue, io->bio, BLK_TA_COMPLETE); bio_endio(io->bio, io->bio->bi_size, io->error); free_io(io->md, io); } } static int clone_endio(struct bio *bio, unsigned int done, int error) { int r = 0; struct target_io *tio = bio->bi_private; struct dm_io *io = tio->io; dm_endio_fn endio = tio->ti->type->end_io; if (bio->bi_size) return 1; if (!bio_flagged(bio, BIO_UPTODATE) && !error) error = -EIO; if (endio) { r = endio(tio->ti, bio, error, &tio->info); if (r < 0) error = r; else if (r > 0) /* the target wants another shot at the io */ return 1; } free_tio(io->md, tio); dec_pending(io, error); bio_put(bio); return r; } static sector_t max_io_len(struct mapped_device *md, sector_t sector, struct dm_target *ti) { sector_t offset = sector - ti->begin; sector_t len = ti->len - offset; /* * Does the target need to split even further ? */ if (ti->split_io) { sector_t boundary; boundary = ((offset + ti->split_io) & ~(ti->split_io - 1)) - offset; if (len > boundary) len = boundary; } return len; } static void __map_bio(struct dm_target *ti, struct bio *clone, struct target_io *tio) { int r; sector_t sector; /* * Sanity checks. */ BUG_ON(!clone->bi_size); clone->bi_end_io = clone_endio; clone->bi_private = tio; /* * Map the clone. If r == 0 we don't need to do * anything, the target has assumed ownership of * this io. */ atomic_inc(&tio->io->io_count); sector = clone->bi_sector; r = ti->type->map(ti, clone, &tio->info); if (r > 0) { /* the bio has been remapped so dispatch it */ blk_add_trace_remap(bdev_get_queue(clone->bi_bdev), clone, tio->io->bio->bi_bdev->bd_dev, sector, clone->bi_sector); generic_make_request(clone); } else if (r < 0) { /* error the io and bail out */ struct dm_io *io = tio->io;


context:
space:
mode: