* - by now the stack is part of the init task */
        printk("Memory %08lx-%08lx\n", memory_start, memory_end);
 
-       if (memory_start == memory_end) BUG();
+       BUG_ON(memory_start == memory_end);
 
        init_mm.start_code = (unsigned long) &_stext;
        init_mm.end_code = (unsigned long) &_etext;
 
                }
        }
 
-       if (HWGROUP(drive)->handler != NULL)
-               BUG();
+       BUG_ON(HWGROUP(drive)->handler != NULL);
 
        ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
        return ide_started;
 
        ide_hwif_t *hwif = HWIF(drive);
        struct scatterlist *sg = hwif->sg_table;
 
-       if ((rq->flags & REQ_DRIVE_TASKFILE) && rq->nr_sectors > 256)
-               BUG();
+       BUG_ON((rq->flags & REQ_DRIVE_TASKFILE) && rq->nr_sectors > 256);
 
        ide_map_sg(drive, rq);
 
        }
        printk("\n");
 
-       if (!(hwif->dma_master))
-               BUG();
+       BUG_ON(!hwif->dma_master);
 }
 
 EXPORT_SYMBOL_GPL(ide_setup_dma);
 
                                        "to send us more data than expected "
                                        "- discarding data\n");
                                idefloppy_discard_data(drive,bcount.all);
-                               if (HWGROUP(drive)->handler != NULL)
-                                       BUG();
+                               BUG_ON(HWGROUP(drive)->handler != NULL);
                                ide_set_handler(drive,
                                                &idefloppy_pc_intr,
                                                IDEFLOPPY_WAIT_CMD,
        pc->actually_transferred += bcount.all;
        pc->current_position += bcount.all;
 
-       if (HWGROUP(drive)->handler != NULL)
-               BUG();
+       BUG_ON(HWGROUP(drive)->handler != NULL);
        ide_set_handler(drive, &idefloppy_pc_intr, IDEFLOPPY_WAIT_CMD, NULL);           /* And set the interrupt handler again */
        return ide_started;
 }
                                "issuing a packet command\n");
                return ide_do_reset(drive);
        }
-       if (HWGROUP(drive)->handler != NULL)
-               BUG();
+       BUG_ON(HWGROUP(drive)->handler != NULL);
        /* Set the interrupt routine */
        ide_set_handler(drive, &idefloppy_pc_intr, IDEFLOPPY_WAIT_CMD, NULL);
        /* Send the actual packet */
         * 40 and 50msec work well. idefloppy_pc_intr will not be actually
         * used until after the packet is moved in about 50 msec.
         */
-       if (HWGROUP(drive)->handler != NULL)
-               BUG();
+       BUG_ON(HWGROUP(drive)->handler != NULL);
        ide_set_handler(drive, 
          &idefloppy_pc_intr,           /* service routine for packet command */
          floppy->ticks,                /* wait this long before "failing" */
 
        
        spin_lock_irqsave(&ide_lock, flags);
        
-       if(hwgroup->handler)
-               BUG();
+       BUG_ON(hwgroup->handler);
        hwgroup->handler        = handler;
        hwgroup->expiry         = expiry;
        hwgroup->timer.expires  = jiffies + timeout;
                printk("%s: ATAPI reset complete\n", drive->name);
        } else {
                if (time_before(jiffies, hwgroup->poll_timeout)) {
-                       if (HWGROUP(drive)->handler != NULL)
-                               BUG();
+                       BUG_ON(HWGROUP(drive)->handler != NULL);
                        ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20, NULL);
                        /* continue polling */
                        return ide_started;
 
        if (!OK_STAT(tmp = hwif->INB(IDE_STATUS_REG), 0, BUSY_STAT)) {
                if (time_before(jiffies, hwgroup->poll_timeout)) {
-                       if (HWGROUP(drive)->handler != NULL)
-                               BUG();
+                       BUG_ON(HWGROUP(drive)->handler != NULL);
                        ide_set_handler(drive, &reset_pollfunc, HZ/20, NULL);
                        /* continue polling */
                        return ide_started;
        hwgroup = HWGROUP(drive);
 
        /* We must not reset with running handlers */
-       if(hwgroup->handler != NULL)
-               BUG();
+       BUG_ON(hwgroup->handler != NULL);
 
        /* For an ATAPI device, first try an ATAPI SRST. */
        if (drive->media != ide_disk && !do_not_try_atapi) {
 
 //     printk("%s: mode 0x%02x, speed 0x%02x\n", __FUNCTION__, mode, speed);
 
        /* So that we remember to update this if new modes appear */
-       if (mode > 4)
-               BUG();
+       BUG_ON(mode > 4);
        return min(speed, speed_max[mode]);
 #else /* !CONFIG_BLK_DEV_IDEDMA */
        return min(speed, (u8)XFER_PIO_4);
 
        if (stat & (ERR_STAT|DRQ_STAT))
                return ide_error(drive, "set_geometry_intr", stat);
 
-       if (HWGROUP(drive)->handler != NULL)
-               BUG();
+       BUG_ON(HWGROUP(drive)->handler != NULL);
        ide_set_handler(drive, &set_geometry_intr, WAIT_WORSTCASE, NULL);
        return ide_started;
 }
 
 
                        ide_abort(drive, "drive reset");
 
-                       if(HWGROUP(drive)->handler)
-                               BUG();
+                       BUG_ON(HWGROUP(drive)->handler);
                                
                        /* Ensure nothing gets queued after we
                           drop the lock. Reset will clear the busy */
 
 {
        ide_hwif_t *hwif        = HWIF(drive);
 
-       if (HWGROUP(drive)->handler != NULL)    /* paranoia check */
-               BUG();
+       BUG_ON(HWGROUP(drive)->handler != NULL);        /* paranoia check */
        ide_set_handler(drive, &ide_dma_intr, WAIT_CMD, NULL);
        /* issue cmd to drive */
        hwif->OUTB(command, IDE_COMMAND_REG);
 
                ioread32(hostdata->base + reg);
 #if 1
        /* sanity check the register */
-       if((reg & 0x3) != 0)
-               BUG();
+       BUG_ON((reg & 0x3) != 0);
 #endif
 
        return value;
 
 #if 1
        /* sanity check the register */
-       if((reg & 0x3) != 0)
-               BUG();
+       BUG_ON((reg & 0x3) != 0);
 #endif
 
        bEBus ? iowrite32be(value, hostdata->base + reg): 
 
        scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL;
 
        dprintk((KERN_DEBUG "get_container_name_callback[cpu %d]: t = %ld.\n", smp_processor_id(), jiffies));
-       if (fibptr == NULL)
-               BUG();
+       BUG_ON(fibptr == NULL);
 
        get_name_reply = (struct aac_get_name_resp *) fib_data(fibptr);
        /* Failure is irrelevant, using default value instead */
                  smp_processor_id(), (unsigned long long)lba, jiffies);
        }
 
-       if (fibptr == NULL)
-               BUG();
+       BUG_ON(fibptr == NULL);
                
        if(scsicmd->use_sg)
                pci_unmap_sg(dev->pdev, 
                
                aac_build_sgraw(scsicmd, &readcmd->sg);
                fibsize = sizeof(struct aac_raw_io) + ((le32_to_cpu(readcmd->sg.count) - 1) * sizeof (struct sgentryraw));
-               if (fibsize > (dev->max_fib_size - sizeof(struct aac_fibhdr)))
-                       BUG();
+               BUG_ON(fibsize > (dev->max_fib_size - sizeof(struct aac_fibhdr)));
                /*
                 *      Now send the Fib to the adapter
                 */
                
                aac_build_sgraw(scsicmd, &writecmd->sg);
                fibsize = sizeof(struct aac_raw_io) + ((le32_to_cpu(writecmd->sg.count) - 1) * sizeof (struct sgentryraw));
-               if (fibsize > (dev->max_fib_size - sizeof(struct aac_fibhdr)))
-                       BUG();
+               BUG_ON(fibsize > (dev->max_fib_size - sizeof(struct aac_fibhdr)));
                /*
                 *      Now send the Fib to the adapter
                 */
        scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL;
        dev = (struct aac_dev *)scsicmd->device->host->hostdata;
 
-       if (fibptr == NULL)
-               BUG();
+       BUG_ON(fibptr == NULL);
 
        srbreply = (struct aac_srb_reply *) fib_data(fibptr);
 
 
 static void fib_dealloc(struct fib * fibptr)
 {
        struct hw_fib *hw_fib = fibptr->hw_fib;
-       if(hw_fib->header.StructType != FIB_MAGIC) 
-               BUG();
+       BUG_ON(hw_fib->header.StructType != FIB_MAGIC);
        hw_fib->header.XferState = 0;        
 }
 
                        }
                } else
                        down(&fibptr->event_wait);
-               if(fibptr->done == 0)
-                       BUG();
+               BUG_ON(fibptr->done == 0);
                        
                if((fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT)){
                        return -ETIMEDOUT;
 
        list_del(l);
 
        q = list_entry(l, QE_t, list);
-       if (BAD_MAGIC(q, QUEUE_MAGIC_FREE))
-               BUG();
+       BUG_ON(BAD_MAGIC(q, QUEUE_MAGIC_FREE));
 
        SET_MAGIC(q, QUEUE_MAGIC_USED);
        q->SCpnt = SCpnt;
         */
        list_del(ent);
        q = list_entry(ent, QE_t, list);
-       if (BAD_MAGIC(q, QUEUE_MAGIC_USED))
-               BUG();
+       BUG_ON(BAD_MAGIC(q, QUEUE_MAGIC_USED));
 
        SET_MAGIC(q, QUEUE_MAGIC_FREE);
        list_add(ent, &queue->free);
 
        int host_index;
        unsigned long imm_command;
 
-       if (cmd == NULL)
-               BUG();
+       BUG_ON(cmd == NULL);
 
        ticks = IM_RESET_DELAY * HZ;
        shpnt = cmd->device->host;
 
                                "issuing a packet command\n");
                return ide_do_reset (drive);
        }
-       if (HWGROUP(drive)->handler != NULL)
-               BUG();
+       BUG_ON(HWGROUP(drive)->handler != NULL);
        /* Set the interrupt routine */
        ide_set_handler(drive, &idescsi_pc_intr, get_timeout(pc), idescsi_expiry);
        /* Send the actual packet */
                set_bit(PC_DMA_OK, &pc->flags);
 
        if (test_bit(IDESCSI_DRQ_INTERRUPT, &scsi->flags)) {
-               if (HWGROUP(drive)->handler != NULL)
-                       BUG();
+               BUG_ON(HWGROUP(drive)->handler != NULL);
                ide_set_handler(drive, &idescsi_transfer_pc,
                                get_timeout(pc), idescsi_expiry);
                /* Issue the packet command */
 
 
        scb->dma_type = MEGA_SGLIST;
 
-       if( sgcnt > adapter->sglen ) BUG();
+       BUG_ON(sgcnt > adapter->sglen);
 
        *len = 0;
 
 
                down_read(&mm->mmap_sem);
        }
        atomic_inc(&mm->mm_count);
-       if (mm != tsk->active_mm) BUG();
+       BUG_ON(mm != tsk->active_mm);
        /* more a memory barrier than a real lock */
        task_lock(tsk);
        tsk->mm = NULL;
                if (options & __WNOTHREAD)
                        break;
                tsk = next_thread(tsk);
-               if (tsk->signal != current->signal)
-                       BUG();
+               BUG_ON(tsk->signal != current->signal);
        } while (tsk != current);
 
        read_unlock(&tasklist_lock);
 
        unsigned long flags;
        int ret = 0;
 
-       if (fn == NULL)
-               BUG();          /* Hard to diagnose if it's deferred */
+       BUG_ON(fn == NULL);     /* Hard to diagnose if it's deferred */
 
        spin_lock_irqsave(&pdflush_lock, flags);
        if (list_empty(&pdflush_list)) {