diff -Nuar LiS-2.18.0.orig/head/head.c LiS-2.18.0/head/head.c
--- LiS-2.18.0.orig/head/head.c 2004-10-05 18:49:04.000000000 +0200
+++ LiS-2.18.0/head/head.c 2005-08-18 11:18:24.000000000 +0300
@@ -418,7 +418,7 @@
"%u:CPU%u in %s() %s #%d -- %p 0x%lx\n";
#if defined(LINUX)
-#define CPCPU smp_processor_id()
+#define CPCPU __smp_processor_id()
#else
#define CPCPU 0
#endif
diff -Nuar LiS-2.18.0.orig/head/linux/exports.c LiS-2.18.0/head/linux/exports.c
--- LiS-2.18.0.orig/head/linux/exports.c 2004-09-16 19:42:48.000000000 +0300
+++ LiS-2.18.0/head/linux/exports.c 2005-08-18 11:18:19.000000000 +0300
@@ -88,311 +88,311 @@
* *
************************************************************************/
-EXPORT_SYMBOL_NOVERS(lis_adjmsg);
-EXPORT_SYMBOL_NOVERS(lis_alloc_atomic_fcn);
-EXPORT_SYMBOL_NOVERS(lis_allocb);
-EXPORT_SYMBOL_NOVERS(lis_allocb_physreq);
-EXPORT_SYMBOL_NOVERS(lis_alloc_dma_fcn);
-EXPORT_SYMBOL_NOVERS(lis_alloc_kernel_fcn);
-EXPORT_SYMBOL_NOVERS(lis_appq);
-EXPORT_SYMBOL_NOVERS(lis_apush_get); /* for sad */
-EXPORT_SYMBOL_NOVERS(lis_apush_set); /* for sad */
-EXPORT_SYMBOL_NOVERS(lis_assert_fail);
-EXPORT_SYMBOL_NOVERS(lis_atomic_add);
-EXPORT_SYMBOL_NOVERS(lis_atomic_dec);
-EXPORT_SYMBOL_NOVERS(lis_atomic_dec_and_test);
-EXPORT_SYMBOL_NOVERS(lis_atomic_inc);
-EXPORT_SYMBOL_NOVERS(lis_atomic_read);
-EXPORT_SYMBOL_NOVERS(lis_atomic_set);
-EXPORT_SYMBOL_NOVERS(lis_atomic_sub);
-EXPORT_SYMBOL_NOVERS(lis_backq);
-EXPORT_SYMBOL_NOVERS(lis_backq_fcn);
-EXPORT_SYMBOL_NOVERS(lis_bcanput);
-EXPORT_SYMBOL_NOVERS(lis_bcanputnext);
-EXPORT_SYMBOL_NOVERS(lis_bcanputnext_anyband);
-EXPORT_SYMBOL_NOVERS(lis_bufcall);
-EXPORT_SYMBOL_NOVERS(lis_clone_major);
-EXPORT_SYMBOL_NOVERS(lis_cmn_err);
-EXPORT_SYMBOL_NOVERS(lis_copyb);
-EXPORT_SYMBOL_NOVERS(lis_copymsg);
-EXPORT_SYMBOL_NOVERS(lis_date);
-EXPORT_SYMBOL_NOVERS(lis_debug_mask);
-EXPORT_SYMBOL_NOVERS(lis_debug_mask2);
+EXPORT_SYMBOL(lis_adjmsg);
+EXPORT_SYMBOL(lis_alloc_atomic_fcn);
+EXPORT_SYMBOL(lis_allocb);
+EXPORT_SYMBOL(lis_allocb_physreq);
+EXPORT_SYMBOL(lis_alloc_dma_fcn);
+EXPORT_SYMBOL(lis_alloc_kernel_fcn);
+EXPORT_SYMBOL(lis_appq);
+EXPORT_SYMBOL(lis_apush_get); /* for sad */
+EXPORT_SYMBOL(lis_apush_set); /* for sad */
+EXPORT_SYMBOL(lis_assert_fail);
+EXPORT_SYMBOL(lis_atomic_add);
+EXPORT_SYMBOL(lis_atomic_dec);
+EXPORT_SYMBOL(lis_atomic_dec_and_test);
+EXPORT_SYMBOL(lis_atomic_inc);
+EXPORT_SYMBOL(lis_atomic_read);
+EXPORT_SYMBOL(lis_atomic_set);
+EXPORT_SYMBOL(lis_atomic_sub);
+EXPORT_SYMBOL(lis_backq);
+EXPORT_SYMBOL(lis_backq_fcn);
+EXPORT_SYMBOL(lis_bcanput);
+EXPORT_SYMBOL(lis_bcanputnext);
+EXPORT_SYMBOL(lis_bcanputnext_anyband);
+EXPORT_SYMBOL(lis_bufcall);
+EXPORT_SYMBOL(lis_clone_major);
+EXPORT_SYMBOL(lis_cmn_err);
+EXPORT_SYMBOL(lis_copyb);
+EXPORT_SYMBOL(lis_copymsg);
+EXPORT_SYMBOL(lis_date);
+EXPORT_SYMBOL(lis_debug_mask);
+EXPORT_SYMBOL(lis_debug_mask2);
#if 0 && defined(CONFIG_DEV)
-EXPORT_SYMBOL_NOVERS(lis_dec_mod_cnt_fcn);
+EXPORT_SYMBOL(lis_dec_mod_cnt_fcn);
#endif
-EXPORT_SYMBOL_NOVERS(lis_disable_irq);
-EXPORT_SYMBOL_NOVERS(lis_down_fcn);
-EXPORT_SYMBOL_NOVERS(lis_down_nosig_fcn);
-EXPORT_SYMBOL_NOVERS(lis_dsecs);
-EXPORT_SYMBOL_NOVERS(lis_dupb);
-EXPORT_SYMBOL_NOVERS(lis_dupmsg);
-EXPORT_SYMBOL_NOVERS(lis_enable_irq);
-EXPORT_SYMBOL_NOVERS(lis_esballoc);
-EXPORT_SYMBOL_NOVERS(lis_esbbcall);
-EXPORT_SYMBOL_NOVERS(lis_flushband);
-EXPORT_SYMBOL_NOVERS(lis_flushq);
-EXPORT_SYMBOL_NOVERS(lis_free);
-EXPORT_SYMBOL_NOVERS(lis_freeb);
-EXPORT_SYMBOL_NOVERS(lis_free_dma);
-EXPORT_SYMBOL_NOVERS(lis_free_irq);
-EXPORT_SYMBOL_NOVERS(lis_free_mem_fcn);
-EXPORT_SYMBOL_NOVERS(lis_freemsg);
-EXPORT_SYMBOL_NOVERS(lis_free_pages_fcn);
-EXPORT_SYMBOL_NOVERS(lis_freezestr);
-EXPORT_SYMBOL_NOVERS(lis_get_free_pages_atomic_fcn);
-EXPORT_SYMBOL_NOVERS(lis_get_free_pages_fcn);
-EXPORT_SYMBOL_NOVERS(lis_get_free_pages_kernel_fcn);
-EXPORT_SYMBOL_NOVERS(lis_getint);
-EXPORT_SYMBOL_NOVERS(lis_getq);
-EXPORT_SYMBOL_NOVERS(lis_gettimeofday);
-EXPORT_SYMBOL_NOVERS(lis_hitime);
+EXPORT_SYMBOL(lis_disable_irq);
+EXPORT_SYMBOL(lis_down_fcn);
+EXPORT_SYMBOL(lis_down_nosig_fcn);
+EXPORT_SYMBOL(lis_dsecs);
+EXPORT_SYMBOL(lis_dupb);
+EXPORT_SYMBOL(lis_dupmsg);
+EXPORT_SYMBOL(lis_enable_irq);
+EXPORT_SYMBOL(lis_esballoc);
+EXPORT_SYMBOL(lis_esbbcall);
+EXPORT_SYMBOL(lis_flushband);
+EXPORT_SYMBOL(lis_flushq);
+EXPORT_SYMBOL(lis_free);
+EXPORT_SYMBOL(lis_freeb);
+EXPORT_SYMBOL(lis_free_dma);
+EXPORT_SYMBOL(lis_free_irq);
+EXPORT_SYMBOL(lis_free_mem_fcn);
+EXPORT_SYMBOL(lis_freemsg);
+EXPORT_SYMBOL(lis_free_pages_fcn);
+EXPORT_SYMBOL(lis_freezestr);
+EXPORT_SYMBOL(lis_get_free_pages_atomic_fcn);
+EXPORT_SYMBOL(lis_get_free_pages_fcn);
+EXPORT_SYMBOL(lis_get_free_pages_kernel_fcn);
+EXPORT_SYMBOL(lis_getint);
+EXPORT_SYMBOL(lis_getq);
+EXPORT_SYMBOL(lis_gettimeofday);
+EXPORT_SYMBOL(lis_hitime);
#if 0 && defined(CONFIG_DEV)
-EXPORT_SYMBOL_NOVERS(lis_inc_mod_cnt_fcn);
+EXPORT_SYMBOL(lis_inc_mod_cnt_fcn);
#endif
-EXPORT_SYMBOL_NOVERS(lis_insq);
-EXPORT_SYMBOL_NOVERS(lis_in_interrupt);
-EXPORT_SYMBOL_NOVERS(lis_interruptible_sleep_on);
-EXPORT_SYMBOL_NOVERS(lis_interruptible_sleep_on_timeout);
-EXPORT_SYMBOL_NOVERS(lis_ioremap);
-EXPORT_SYMBOL_NOVERS(lis_ioremap_nocache);
-EXPORT_SYMBOL_NOVERS(lis_iounmap);
-EXPORT_SYMBOL_NOVERS(lis_irqreturn_handled);
-EXPORT_SYMBOL_NOVERS(lis_irqreturn_not_handled);
-EXPORT_SYMBOL_NOVERS(lis_jiffies);
-EXPORT_SYMBOL_NOVERS(lis_kernel_down);
-EXPORT_SYMBOL_NOVERS(lis_kernel_up);
-EXPORT_SYMBOL_NOVERS(lis_kernel_version);
-EXPORT_SYMBOL_NOVERS(lis_kfree);
-EXPORT_SYMBOL_NOVERS(lis_kmalloc);
-EXPORT_SYMBOL_NOVERS(lis_linkb);
-EXPORT_SYMBOL_NOVERS(lis_getmajor);
-EXPORT_SYMBOL_NOVERS(lis_getminor);
-EXPORT_SYMBOL_NOVERS(lis_makedevice);
-EXPORT_SYMBOL_NOVERS(lis_major);
-EXPORT_SYMBOL_NOVERS(lis_malloc);
-EXPORT_SYMBOL_NOVERS(lis_mark_mem_fcn);
+EXPORT_SYMBOL(lis_insq);
+EXPORT_SYMBOL(lis_in_interrupt);
+EXPORT_SYMBOL(lis_interruptible_sleep_on);
+EXPORT_SYMBOL(lis_interruptible_sleep_on_timeout);
+EXPORT_SYMBOL(lis_ioremap);
+EXPORT_SYMBOL(lis_ioremap_nocache);
+EXPORT_SYMBOL(lis_iounmap);
+EXPORT_SYMBOL(lis_irqreturn_handled);
+EXPORT_SYMBOL(lis_irqreturn_not_handled);
+EXPORT_SYMBOL(lis_jiffies);
+EXPORT_SYMBOL(lis_kernel_down);
+EXPORT_SYMBOL(lis_kernel_up);
+EXPORT_SYMBOL(lis_kernel_version);
+EXPORT_SYMBOL(lis_kfree);
+EXPORT_SYMBOL(lis_kmalloc);
+EXPORT_SYMBOL(lis_linkb);
+EXPORT_SYMBOL(lis_getmajor);
+EXPORT_SYMBOL(lis_getminor);
+EXPORT_SYMBOL(lis_makedevice);
+EXPORT_SYMBOL(lis_major);
+EXPORT_SYMBOL(lis_malloc);
+EXPORT_SYMBOL(lis_mark_mem_fcn);
#if (!defined(_S390_LIS_) && !defined(_S390X_LIS_))
-EXPORT_SYMBOL_NOVERS(lis_membar);
+EXPORT_SYMBOL(lis_membar);
#endif /* S390 or S390X */
-EXPORT_SYMBOL_NOVERS(lis_milli_to_ticks);
-EXPORT_SYMBOL_NOVERS(lis_mknod);
+EXPORT_SYMBOL(lis_milli_to_ticks);
+EXPORT_SYMBOL(lis_mknod);
#if 0 && defined(CONFIG_DEV)
-EXPORT_SYMBOL_NOVERS(lis_mod_cnt_sync_fcn);
+EXPORT_SYMBOL(lis_mod_cnt_sync_fcn);
#endif
-EXPORT_SYMBOL_NOVERS(lis_msecs);
-EXPORT_SYMBOL_NOVERS(lis_msgdsize);
-EXPORT_SYMBOL_NOVERS(lis_msgpullup);
-EXPORT_SYMBOL_NOVERS(lis_msgsize);
-EXPORT_SYMBOL_NOVERS(lis_msg_type_name);
-EXPORT_SYMBOL_NOVERS(lis_num_cpus);
-EXPORT_SYMBOL_NOVERS(lis_osif_cli);
-EXPORT_SYMBOL_NOVERS(lis_osif_do_gettimeofday);
-EXPORT_SYMBOL_NOVERS(lis_osif_do_settimeofday);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_disable_device);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_enable_device);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_find_class);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_find_device);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_find_slot);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_module_init);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_read_config_byte);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_read_config_dword);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_read_config_word);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_set_master);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_unregister_driver);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_write_config_byte);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_write_config_dword);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_write_config_word);
-EXPORT_SYMBOL_NOVERS(lis_osif_sti);
-EXPORT_SYMBOL_NOVERS(lis_own_spl);
+EXPORT_SYMBOL(lis_msecs);
+EXPORT_SYMBOL(lis_msgdsize);
+EXPORT_SYMBOL(lis_msgpullup);
+EXPORT_SYMBOL(lis_msgsize);
+EXPORT_SYMBOL(lis_msg_type_name);
+EXPORT_SYMBOL(lis_num_cpus);
+EXPORT_SYMBOL(lis_osif_cli);
+EXPORT_SYMBOL(lis_osif_do_gettimeofday);
+EXPORT_SYMBOL(lis_osif_do_settimeofday);
+EXPORT_SYMBOL(lis_osif_pci_disable_device);
+EXPORT_SYMBOL(lis_osif_pci_enable_device);
+EXPORT_SYMBOL(lis_osif_pci_find_class);
+EXPORT_SYMBOL(lis_osif_pci_find_device);
+EXPORT_SYMBOL(lis_osif_pci_find_slot);
+EXPORT_SYMBOL(lis_osif_pci_module_init);
+EXPORT_SYMBOL(lis_osif_pci_read_config_byte);
+EXPORT_SYMBOL(lis_osif_pci_read_config_dword);
+EXPORT_SYMBOL(lis_osif_pci_read_config_word);
+EXPORT_SYMBOL(lis_osif_pci_set_master);
+EXPORT_SYMBOL(lis_osif_pci_unregister_driver);
+EXPORT_SYMBOL(lis_osif_pci_write_config_byte);
+EXPORT_SYMBOL(lis_osif_pci_write_config_dword);
+EXPORT_SYMBOL(lis_osif_pci_write_config_word);
+EXPORT_SYMBOL(lis_osif_sti);
+EXPORT_SYMBOL(lis_own_spl);
#if (!defined(_S390_LIS_) && !defined(_S390X_LIS_))
-EXPORT_SYMBOL_NOVERS(lis_pcibios_find_class);
-EXPORT_SYMBOL_NOVERS(lis_pcibios_find_device);
-EXPORT_SYMBOL_NOVERS(lis_pcibios_init);
-EXPORT_SYMBOL_NOVERS(lis_pcibios_present);
-EXPORT_SYMBOL_NOVERS(lis_pcibios_read_config_byte);
-EXPORT_SYMBOL_NOVERS(lis_pcibios_read_config_dword);
-EXPORT_SYMBOL_NOVERS(lis_pcibios_read_config_word);
-EXPORT_SYMBOL_NOVERS(lis_pcibios_strerror);
-EXPORT_SYMBOL_NOVERS(lis_pcibios_write_config_byte);
-EXPORT_SYMBOL_NOVERS(lis_pcibios_write_config_dword);
-EXPORT_SYMBOL_NOVERS(lis_pcibios_write_config_word);
-EXPORT_SYMBOL_NOVERS(lis_pci_alloc_consistent);
-EXPORT_SYMBOL_NOVERS(lis_pci_disable_device);
-EXPORT_SYMBOL_NOVERS(lis_pci_dma_handle_to_32);
-EXPORT_SYMBOL_NOVERS(lis_pci_dma_handle_to_64);
-EXPORT_SYMBOL_NOVERS(lis_pci_dma_supported);
-EXPORT_SYMBOL_NOVERS(lis_pci_dma_sync_single);
-EXPORT_SYMBOL_NOVERS(lis_pci_enable_device);
-EXPORT_SYMBOL_NOVERS(lis_pci_find_class);
-EXPORT_SYMBOL_NOVERS(lis_pci_find_device);
-EXPORT_SYMBOL_NOVERS(lis_pci_find_slot);
-EXPORT_SYMBOL_NOVERS(lis_pci_free_consistent);
-EXPORT_SYMBOL_NOVERS(lis_pci_map_single);
-EXPORT_SYMBOL_NOVERS(lis_pci_read_config_byte);
-EXPORT_SYMBOL_NOVERS(lis_pci_read_config_dword);
-EXPORT_SYMBOL_NOVERS(lis_pci_read_config_word);
-EXPORT_SYMBOL_NOVERS(lis_pci_set_dma_mask);
-EXPORT_SYMBOL_NOVERS(lis_pci_set_master);
-EXPORT_SYMBOL_NOVERS(lis_pci_unmap_single);
-EXPORT_SYMBOL_NOVERS(lis_pci_write_config_byte);
-EXPORT_SYMBOL_NOVERS(lis_pci_write_config_dword);
-EXPORT_SYMBOL_NOVERS(lis_pci_write_config_word);
+EXPORT_SYMBOL(lis_pcibios_find_class);
+EXPORT_SYMBOL(lis_pcibios_find_device);
+EXPORT_SYMBOL(lis_pcibios_init);
+EXPORT_SYMBOL(lis_pcibios_present);
+EXPORT_SYMBOL(lis_pcibios_read_config_byte);
+EXPORT_SYMBOL(lis_pcibios_read_config_dword);
+EXPORT_SYMBOL(lis_pcibios_read_config_word);
+EXPORT_SYMBOL(lis_pcibios_strerror);
+EXPORT_SYMBOL(lis_pcibios_write_config_byte);
+EXPORT_SYMBOL(lis_pcibios_write_config_dword);
+EXPORT_SYMBOL(lis_pcibios_write_config_word);
+EXPORT_SYMBOL(lis_pci_alloc_consistent);
+EXPORT_SYMBOL(lis_pci_disable_device);
+EXPORT_SYMBOL(lis_pci_dma_handle_to_32);
+EXPORT_SYMBOL(lis_pci_dma_handle_to_64);
+EXPORT_SYMBOL(lis_pci_dma_supported);
+EXPORT_SYMBOL(lis_pci_dma_sync_single);
+EXPORT_SYMBOL(lis_pci_enable_device);
+EXPORT_SYMBOL(lis_pci_find_class);
+EXPORT_SYMBOL(lis_pci_find_device);
+EXPORT_SYMBOL(lis_pci_find_slot);
+EXPORT_SYMBOL(lis_pci_free_consistent);
+EXPORT_SYMBOL(lis_pci_map_single);
+EXPORT_SYMBOL(lis_pci_read_config_byte);
+EXPORT_SYMBOL(lis_pci_read_config_dword);
+EXPORT_SYMBOL(lis_pci_read_config_word);
+EXPORT_SYMBOL(lis_pci_set_dma_mask);
+EXPORT_SYMBOL(lis_pci_set_master);
+EXPORT_SYMBOL(lis_pci_unmap_single);
+EXPORT_SYMBOL(lis_pci_write_config_byte);
+EXPORT_SYMBOL(lis_pci_write_config_dword);
+EXPORT_SYMBOL(lis_pci_write_config_word);
#endif /* S390 or S390X */
-EXPORT_SYMBOL_NOVERS(lis_phys_to_virt);
-EXPORT_SYMBOL_NOVERS(lis_print_block);
-EXPORT_SYMBOL_NOVERS(lis_print_data);
-EXPORT_SYMBOL_NOVERS(lis_printk);
-EXPORT_SYMBOL_NOVERS(lis_print_mem);
-EXPORT_SYMBOL_NOVERS(lis_print_msg);
-EXPORT_SYMBOL_NOVERS(lis_print_queue);
-EXPORT_SYMBOL_NOVERS(lis_pullupmsg);
-EXPORT_SYMBOL_NOVERS(lis_putbq);
-EXPORT_SYMBOL_NOVERS(lis_putbqf);
-EXPORT_SYMBOL_NOVERS(lis_putbyte);
-EXPORT_SYMBOL_NOVERS(lis_putctl);
-EXPORT_SYMBOL_NOVERS(lis_putctl1);
-EXPORT_SYMBOL_NOVERS(lis_putnextctl);
-EXPORT_SYMBOL_NOVERS(lis_putnextctl1);
-EXPORT_SYMBOL_NOVERS(lis_putq);
-EXPORT_SYMBOL_NOVERS(lis_putqf);
-EXPORT_SYMBOL_NOVERS(lis_qcountstrm);
-EXPORT_SYMBOL_NOVERS(lis_qenable);
-EXPORT_SYMBOL_NOVERS(lis_qprocsoff);
-EXPORT_SYMBOL_NOVERS(lis_qprocson);
-EXPORT_SYMBOL_NOVERS(lis_qsize);
-EXPORT_SYMBOL_NOVERS(lis_queue_name);
-EXPORT_SYMBOL_NOVERS(lis_register_strdev);
-EXPORT_SYMBOL_NOVERS(lis_register_strmod);
-EXPORT_SYMBOL_NOVERS(lis_register_driver_qlock_option);
-EXPORT_SYMBOL_NOVERS(lis_register_module_qlock_option);
-EXPORT_SYMBOL_NOVERS(lis_release_region);
-EXPORT_SYMBOL_NOVERS(lis_request_dma);
-EXPORT_SYMBOL_NOVERS(lis_request_irq);
-EXPORT_SYMBOL_NOVERS(lis_request_region);
-EXPORT_SYMBOL_NOVERS(lis_rmvb);
-EXPORT_SYMBOL_NOVERS(lis_rmvq);
-EXPORT_SYMBOL_NOVERS(lis_rw_lock_alloc_fcn);
-EXPORT_SYMBOL_NOVERS(lis_rw_lock_free_fcn);
-EXPORT_SYMBOL_NOVERS(lis_rw_lock_init_fcn);
-EXPORT_SYMBOL_NOVERS(lis_rw_read_lock_fcn);
-EXPORT_SYMBOL_NOVERS(lis_rw_read_lock_irq_fcn);
-EXPORT_SYMBOL_NOVERS(lis_rw_read_lock_irqsave_fcn);
-EXPORT_SYMBOL_NOVERS(lis_rw_read_unlock_fcn);
-EXPORT_SYMBOL_NOVERS(lis_rw_read_unlock_irq_fcn);
-EXPORT_SYMBOL_NOVERS(lis_rw_read_unlock_irqrestore_fcn);
-EXPORT_SYMBOL_NOVERS(lis_rw_write_lock_fcn);
-EXPORT_SYMBOL_NOVERS(lis_rw_write_lock_irq_fcn);
-EXPORT_SYMBOL_NOVERS(lis_rw_write_lock_irqsave_fcn);
-EXPORT_SYMBOL_NOVERS(lis_rw_write_unlock_fcn);
-EXPORT_SYMBOL_NOVERS(lis_rw_write_unlock_irq_fcn);
-EXPORT_SYMBOL_NOVERS(lis_rw_write_unlock_irqrestore_fcn);
-EXPORT_SYMBOL_NOVERS(lis_safe_canenable);
-EXPORT_SYMBOL_NOVERS(lis_safe_enableok);
-EXPORT_SYMBOL_NOVERS(lis_safe_noenable);
-EXPORT_SYMBOL_NOVERS(lis_safe_OTHERQ);
-EXPORT_SYMBOL_NOVERS(lis_safe_putmsg);
-EXPORT_SYMBOL_NOVERS(lis_safe_putnext);
-EXPORT_SYMBOL_NOVERS(lis_safe_qreply);
-EXPORT_SYMBOL_NOVERS(lis_safe_RD);
-EXPORT_SYMBOL_NOVERS(lis_safe_SAMESTR);
-EXPORT_SYMBOL_NOVERS(lis_safe_WR);
-EXPORT_SYMBOL_NOVERS(lis_secs);
-EXPORT_SYMBOL_NOVERS(lis_sem_alloc);
-EXPORT_SYMBOL_NOVERS(lis_sem_destroy);
-EXPORT_SYMBOL_NOVERS(lis_sem_init);
-EXPORT_SYMBOL_NOVERS(lis_sleep_on);
-EXPORT_SYMBOL_NOVERS(lis_sleep_on_timeout);
-EXPORT_SYMBOL_NOVERS(lis_wait_event);
-EXPORT_SYMBOL_NOVERS(lis_wait_event_interruptible);
-EXPORT_SYMBOL_NOVERS(lis_spin_is_locked_fcn);
-EXPORT_SYMBOL_NOVERS(lis_spin_lock_alloc_fcn);
-EXPORT_SYMBOL_NOVERS(lis_spin_lock_fcn);
-EXPORT_SYMBOL_NOVERS(lis_spin_lock_free_fcn);
-EXPORT_SYMBOL_NOVERS(lis_spin_lock_init_fcn);
-EXPORT_SYMBOL_NOVERS(lis_spin_lock_irq_fcn);
-EXPORT_SYMBOL_NOVERS(lis_spin_lock_irqsave_fcn);
-EXPORT_SYMBOL_NOVERS(lis_spin_trylock_fcn);
-EXPORT_SYMBOL_NOVERS(lis_spin_unlock_fcn);
-EXPORT_SYMBOL_NOVERS(lis_spin_unlock_irq_fcn);
-EXPORT_SYMBOL_NOVERS(lis_spin_unlock_irqrestore_fcn);
-EXPORT_SYMBOL_NOVERS(lis_spl0_fcn);
-EXPORT_SYMBOL_NOVERS(lis_splstr_fcn);
-EXPORT_SYMBOL_NOVERS(lis_splx_fcn);
-EXPORT_SYMBOL_NOVERS(lis_sprintf);
-EXPORT_SYMBOL_NOVERS(lis_strm_name);
-EXPORT_SYMBOL_NOVERS(lis_strm_name_from_queue);
-EXPORT_SYMBOL_NOVERS(lis_stropts_file);
-EXPORT_SYMBOL_NOVERS(lis_strqget);
-EXPORT_SYMBOL_NOVERS(lis_strqset);
-EXPORT_SYMBOL_NOVERS(lis_testb);
-EXPORT_SYMBOL_NOVERS(lis_thread_start);
-EXPORT_SYMBOL_NOVERS(lis_thread_stop);
-EXPORT_SYMBOL_NOVERS(lis_timeout_fcn);
-EXPORT_SYMBOL_NOVERS(lis_udelay);
-EXPORT_SYMBOL_NOVERS(lis_unbufcall);
-EXPORT_SYMBOL_NOVERS(lis_unfreezestr);
-EXPORT_SYMBOL_NOVERS(lis_unlink);
-EXPORT_SYMBOL_NOVERS(lis_unlinkb);
-EXPORT_SYMBOL_NOVERS(lis_unregister_strdev);
-EXPORT_SYMBOL_NOVERS(lis_unregister_strmod);
-EXPORT_SYMBOL_NOVERS(lis_untimeout);
-EXPORT_SYMBOL_NOVERS(lis_up_fcn);
-EXPORT_SYMBOL_NOVERS(lis_usecs);
-EXPORT_SYMBOL_NOVERS(lis_usectohz);
-EXPORT_SYMBOL_NOVERS(lis_version);
-EXPORT_SYMBOL_NOVERS(lis_vfree);
-EXPORT_SYMBOL_NOVERS(lis_virt_to_phys);
-EXPORT_SYMBOL_NOVERS(lis_vmalloc);
-EXPORT_SYMBOL_NOVERS(lis_vremap);
-EXPORT_SYMBOL_NOVERS(lis_vsprintf);
-EXPORT_SYMBOL_NOVERS(lis_wake_up);
-EXPORT_SYMBOL_NOVERS(lis_wake_up_interruptible);
-EXPORT_SYMBOL_NOVERS(lis_xmsgsize);
-EXPORT_SYMBOL_NOVERS(lis_zmalloc);
+EXPORT_SYMBOL(lis_phys_to_virt);
+EXPORT_SYMBOL(lis_print_block);
+EXPORT_SYMBOL(lis_print_data);
+EXPORT_SYMBOL(lis_printk);
+EXPORT_SYMBOL(lis_print_mem);
+EXPORT_SYMBOL(lis_print_msg);
+EXPORT_SYMBOL(lis_print_queue);
+EXPORT_SYMBOL(lis_pullupmsg);
+EXPORT_SYMBOL(lis_putbq);
+EXPORT_SYMBOL(lis_putbqf);
+EXPORT_SYMBOL(lis_putbyte);
+EXPORT_SYMBOL(lis_putctl);
+EXPORT_SYMBOL(lis_putctl1);
+EXPORT_SYMBOL(lis_putnextctl);
+EXPORT_SYMBOL(lis_putnextctl1);
+EXPORT_SYMBOL(lis_putq);
+EXPORT_SYMBOL(lis_putqf);
+EXPORT_SYMBOL(lis_qcountstrm);
+EXPORT_SYMBOL(lis_qenable);
+EXPORT_SYMBOL(lis_qprocsoff);
+EXPORT_SYMBOL(lis_qprocson);
+EXPORT_SYMBOL(lis_qsize);
+EXPORT_SYMBOL(lis_queue_name);
+EXPORT_SYMBOL(lis_register_strdev);
+EXPORT_SYMBOL(lis_register_strmod);
+EXPORT_SYMBOL(lis_register_driver_qlock_option);
+EXPORT_SYMBOL(lis_register_module_qlock_option);
+EXPORT_SYMBOL(lis_release_region);
+EXPORT_SYMBOL(lis_request_dma);
+EXPORT_SYMBOL(lis_request_irq);
+EXPORT_SYMBOL(lis_request_region);
+EXPORT_SYMBOL(lis_rmvb);
+EXPORT_SYMBOL(lis_rmvq);
+EXPORT_SYMBOL(lis_rw_lock_alloc_fcn);
+EXPORT_SYMBOL(lis_rw_lock_free_fcn);
+EXPORT_SYMBOL(lis_rw_lock_init_fcn);
+EXPORT_SYMBOL(lis_rw_read_lock_fcn);
+EXPORT_SYMBOL(lis_rw_read_lock_irq_fcn);
+EXPORT_SYMBOL(lis_rw_read_lock_irqsave_fcn);
+EXPORT_SYMBOL(lis_rw_read_unlock_fcn);
+EXPORT_SYMBOL(lis_rw_read_unlock_irq_fcn);
+EXPORT_SYMBOL(lis_rw_read_unlock_irqrestore_fcn);
+EXPORT_SYMBOL(lis_rw_write_lock_fcn);
+EXPORT_SYMBOL(lis_rw_write_lock_irq_fcn);
+EXPORT_SYMBOL(lis_rw_write_lock_irqsave_fcn);
+EXPORT_SYMBOL(lis_rw_write_unlock_fcn);
+EXPORT_SYMBOL(lis_rw_write_unlock_irq_fcn);
+EXPORT_SYMBOL(lis_rw_write_unlock_irqrestore_fcn);
+EXPORT_SYMBOL(lis_safe_canenable);
+EXPORT_SYMBOL(lis_safe_enableok);
+EXPORT_SYMBOL(lis_safe_noenable);
+EXPORT_SYMBOL(lis_safe_OTHERQ);
+EXPORT_SYMBOL(lis_safe_putmsg);
+EXPORT_SYMBOL(lis_safe_putnext);
+EXPORT_SYMBOL(lis_safe_qreply);
+EXPORT_SYMBOL(lis_safe_RD);
+EXPORT_SYMBOL(lis_safe_SAMESTR);
+EXPORT_SYMBOL(lis_safe_WR);
+EXPORT_SYMBOL(lis_secs);
+EXPORT_SYMBOL(lis_sem_alloc);
+EXPORT_SYMBOL(lis_sem_destroy);
+EXPORT_SYMBOL(lis_sem_init);
+EXPORT_SYMBOL(lis_sleep_on);
+EXPORT_SYMBOL(lis_sleep_on_timeout);
+EXPORT_SYMBOL(lis_wait_event);
+EXPORT_SYMBOL(lis_wait_event_interruptible);
+EXPORT_SYMBOL(lis_spin_is_locked_fcn);
+EXPORT_SYMBOL(lis_spin_lock_alloc_fcn);
+EXPORT_SYMBOL(lis_spin_lock_fcn);
+EXPORT_SYMBOL(lis_spin_lock_free_fcn);
+EXPORT_SYMBOL(lis_spin_lock_init_fcn);
+EXPORT_SYMBOL(lis_spin_lock_irq_fcn);
+EXPORT_SYMBOL(lis_spin_lock_irqsave_fcn);
+EXPORT_SYMBOL(lis_spin_trylock_fcn);
+EXPORT_SYMBOL(lis_spin_unlock_fcn);
+EXPORT_SYMBOL(lis_spin_unlock_irq_fcn);
+EXPORT_SYMBOL(lis_spin_unlock_irqrestore_fcn);
+EXPORT_SYMBOL(lis_spl0_fcn);
+EXPORT_SYMBOL(lis_splstr_fcn);
+EXPORT_SYMBOL(lis_splx_fcn);
+EXPORT_SYMBOL(lis_sprintf);
+EXPORT_SYMBOL(lis_strm_name);
+EXPORT_SYMBOL(lis_strm_name_from_queue);
+EXPORT_SYMBOL(lis_stropts_file);
+EXPORT_SYMBOL(lis_strqget);
+EXPORT_SYMBOL(lis_strqset);
+EXPORT_SYMBOL(lis_testb);
+EXPORT_SYMBOL(lis_thread_start);
+EXPORT_SYMBOL(lis_thread_stop);
+EXPORT_SYMBOL(lis_timeout_fcn);
+EXPORT_SYMBOL(lis_udelay);
+EXPORT_SYMBOL(lis_unbufcall);
+EXPORT_SYMBOL(lis_unfreezestr);
+EXPORT_SYMBOL(lis_unlink);
+EXPORT_SYMBOL(lis_unlinkb);
+EXPORT_SYMBOL(lis_unregister_strdev);
+EXPORT_SYMBOL(lis_unregister_strmod);
+EXPORT_SYMBOL(lis_untimeout);
+EXPORT_SYMBOL(lis_up_fcn);
+EXPORT_SYMBOL(lis_usecs);
+EXPORT_SYMBOL(lis_usectohz);
+EXPORT_SYMBOL(lis_version);
+EXPORT_SYMBOL(lis_vfree);
+EXPORT_SYMBOL(lis_virt_to_phys);
+EXPORT_SYMBOL(lis_vmalloc);
+EXPORT_SYMBOL(lis_vremap);
+EXPORT_SYMBOL(lis_vsprintf);
+EXPORT_SYMBOL(lis_wake_up);
+EXPORT_SYMBOL(lis_wake_up_interruptible);
+EXPORT_SYMBOL(lis_xmsgsize);
+EXPORT_SYMBOL(lis_zmalloc);
#if (!defined(_S390_LIS_) && !defined(_S390X_LIS_))
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_alloc_consistent);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_dma_supported);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_dma_sync_sg);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_dma_sync_single);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_free_consistent);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_map_sg);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_map_single);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_set_dma_mask);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_unmap_sg);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_unmap_single);
-EXPORT_SYMBOL_NOVERS(lis_osif_sg_dma_address);
-EXPORT_SYMBOL_NOVERS(lis_osif_sg_dma_len);
+EXPORT_SYMBOL(lis_osif_pci_alloc_consistent);
+EXPORT_SYMBOL(lis_osif_pci_dma_supported);
+EXPORT_SYMBOL(lis_osif_pci_dma_sync_sg);
+EXPORT_SYMBOL(lis_osif_pci_dma_sync_single);
+EXPORT_SYMBOL(lis_osif_pci_free_consistent);
+EXPORT_SYMBOL(lis_osif_pci_map_sg);
+EXPORT_SYMBOL(lis_osif_pci_map_single);
+EXPORT_SYMBOL(lis_osif_pci_set_dma_mask);
+EXPORT_SYMBOL(lis_osif_pci_unmap_sg);
+EXPORT_SYMBOL(lis_osif_pci_unmap_single);
+EXPORT_SYMBOL(lis_osif_sg_dma_address);
+EXPORT_SYMBOL(lis_osif_sg_dma_len);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,13) /* 2.4.13 or later */
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_dac_set_dma_mask);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_dac_dma_supported);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_unmap_page);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_map_page);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_dac_dma_sync_single);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_dac_dma_to_offset);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_dac_dma_to_page);
-EXPORT_SYMBOL_NOVERS(lis_osif_pci_dac_page_to_dma);
+EXPORT_SYMBOL(lis_osif_pci_dac_set_dma_mask);
+EXPORT_SYMBOL(lis_osif_pci_dac_dma_supported);
+EXPORT_SYMBOL(lis_osif_pci_unmap_page);
+EXPORT_SYMBOL(lis_osif_pci_map_page);
+EXPORT_SYMBOL(lis_osif_pci_dac_dma_sync_single);
+EXPORT_SYMBOL(lis_osif_pci_dac_dma_to_offset);
+EXPORT_SYMBOL(lis_osif_pci_dac_dma_to_page);
+EXPORT_SYMBOL(lis_osif_pci_dac_page_to_dma);
#endif /* 2.4.13 */
/*
* Wrapper functions
*/
-EXPORT_SYMBOL_NOVERS(__wrap_strcpy);
-EXPORT_SYMBOL_NOVERS(__wrap_strncpy);
-EXPORT_SYMBOL_NOVERS(__wrap_strcat);
-EXPORT_SYMBOL_NOVERS(__wrap_strncat);
-EXPORT_SYMBOL_NOVERS(__wrap_strcmp);
-EXPORT_SYMBOL_NOVERS(__wrap_strncmp);
-EXPORT_SYMBOL_NOVERS(__wrap_strnicmp);
-EXPORT_SYMBOL_NOVERS(__wrap_strchr);
-EXPORT_SYMBOL_NOVERS(__wrap_strrchr);
-EXPORT_SYMBOL_NOVERS(__wrap_strstr);
-EXPORT_SYMBOL_NOVERS(__wrap_strlen);
-EXPORT_SYMBOL_NOVERS(__wrap_memset);
-EXPORT_SYMBOL_NOVERS(__wrap_memcpy);
-EXPORT_SYMBOL_NOVERS(__wrap_memcmp);
+EXPORT_SYMBOL(__wrap_strcpy);
+EXPORT_SYMBOL(__wrap_strncpy);
+EXPORT_SYMBOL(__wrap_strcat);
+EXPORT_SYMBOL(__wrap_strncat);
+EXPORT_SYMBOL(__wrap_strcmp);
+EXPORT_SYMBOL(__wrap_strncmp);
+EXPORT_SYMBOL(__wrap_strnicmp);
+EXPORT_SYMBOL(__wrap_strchr);
+EXPORT_SYMBOL(__wrap_strrchr);
+EXPORT_SYMBOL(__wrap_strstr);
+EXPORT_SYMBOL(__wrap_strlen);
+EXPORT_SYMBOL(__wrap_memset);
+EXPORT_SYMBOL(__wrap_memcpy);
+EXPORT_SYMBOL(__wrap_memcmp);
#endif /* S390 or S390X */
diff -Nuar LiS-2.18.0.orig/head/linux/lislocks.c LiS-2.18.0/head/linux/lislocks.c
--- LiS-2.18.0.orig/head/linux/lislocks.c 2004-09-07 19:11:21.000000000 +0300
+++ LiS-2.18.0/head/linux/lislocks.c 2005-08-18 11:18:24.000000000 +0300
@@ -232,7 +232,7 @@
p->type = typ ; \
p->flags = flgs ; \
p->cntr = ++lis_seq_cntr ; \
- p->cpu = smp_processor_id(); \
+ p->cpu = __smp_processor_id(); \
p->state = (lock)->nest ; \
}
@@ -255,7 +255,7 @@
p->type = typ ; \
p->flags = flgs ; \
p->cntr = ++lis_seq_cntr ; \
- p->cpu = smp_processor_id(); \
+ p->cpu = __smp_processor_id(); \
p->state = (lock)->nest ; \
}
@@ -278,7 +278,7 @@
p->type = typ ; \
p->flags = flgs ; \
p->cntr = ++lis_seq_cntr ; \
- p->cpu = smp_processor_id(); \
+ p->cpu = __smp_processor_id(); \
p->state = atomic_read(&((struct semaphore *) &sem->sem_mem)->count); \
}
@@ -301,7 +301,7 @@
p->type = typ ; \
p->flags = flgs ; \
p->cntr = ++lis_seq_cntr ; \
- p->cpu = smp_processor_id(); \
+ p->cpu = __smp_processor_id(); \
p->state = atomic_read(&((struct semaphore *) &sem->sem_mem)->count); \
}
#else
diff -Nuar LiS-2.18.0.orig/head/linux-mdep.c LiS-2.18.0/head/linux-mdep.c
--- LiS-2.18.0.orig/head/linux-mdep.c 2004-10-13 18:07:36.000000000 +0200
+++ LiS-2.18.0/head/linux-mdep.c 2005-08-18 11:18:24.000000000 +0300
@@ -137,7 +137,7 @@
************************************************************************/
static int lis_errnos[LIS_NR_CPUS] ;
-#define errno lis_errnos[smp_processor_id()]
+#define errno lis_errnos[__smp_processor_id()]
#define __NR_syscall_mknod __NR_mknod
#define __NR_syscall_unlink __NR_unlink
@@ -998,7 +998,7 @@
if (inode && inode->i_cdev)
printk(">> i->i_cdev: [EMAIL PROTECTED]/%d/%x \"%s\"\n",
inode->i_cdev,
- K_ATOMIC_READ(&inode->i_cdev->kobj.refcount),
+ K_ATOMIC_READ(&inode->i_cdev->kobj.kref.refcount),
DEV_TO_INT(inode->i_cdev->dev),
(inode->i_cdev->owner ?
inode->i_cdev->owner->name : "No-Owner")) ;
@@ -1015,7 +1015,9 @@
list_del_init(&inode->i_devices);
}
- cdev_put(cp) ;
+ kobject_put(&cp->kobj);
+ module_put(cp->owner);
+
spin_unlock(&lock) ;
#endif
}
@@ -2540,21 +2542,23 @@
static struct inode* lis_fifo_info_new(struct inode* i)
{
- i->i_pipe = kmalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
- if (i->i_pipe) {
+ /*
+ * The following code is based on kernel fs/pipe.c
+ * new_pipe() function
+ */
+ struct pipe_inode_info *info;
+
+ info = kmalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
+ if (!info) {
+ return NULL;
+ }
+ memset(info, 0, sizeof(*info));
+
+ i->i_pipe = info;
init_waitqueue_head(PIPE_WAIT(*i));
- PIPE_BASE(*i) = NULL;;
- PIPE_START(*i) = PIPE_LEN(*i) = 0;
- PIPE_READERS(*i) = PIPE_WRITERS(*i) = 0;
-#if !defined(KERNEL_2_5)
- PIPE_WAITING_READERS(*i) = PIPE_WAITING_WRITERS(*i) = 0;
-#endif
PIPE_RCOUNTER(*i) = PIPE_WCOUNTER(*i) = 1;
return i;
- } else {
- return NULL;
- }
}
int
@@ -4110,7 +4114,7 @@
sig_cnt = 0 ;
lis_runq_wakeups[cpu_id]++ ;
- if (cpu_id != smp_processor_id())
+ if (cpu_id != __smp_processor_id())
{
static int msg_cnt ;
char buf[200] ;
@@ -4122,7 +4126,7 @@
#endif
if (++msg_cnt < 5)
printk("%s woke up running on CPU %d -- cpu_id=%d mask=%s\n",
- current->comm, smp_processor_id(), cpu_id, buf) ;
+ current->comm, __smp_processor_id(), cpu_id, buf) ;
}
/*
* If there are characters queued up in need of printing, print them if
@@ -4195,7 +4199,7 @@
int queue_load_thresh ;
int req_cnt ;
int in_intr = in_interrupt() ;
- int my_cpu = smp_processor_id() ;
+ int my_cpu = __smp_processor_id() ;
int cpu ;
static int qsched_running ;
lis_flags_t psw;
diff -Nuar LiS-2.18.0.orig/head/osif.c LiS-2.18.0/head/osif.c
--- LiS-2.18.0.orig/head/osif.c 2004-10-11 23:49:31.000000000 +0200
+++ LiS-2.18.0/head/osif.c 2005-08-18 11:18:19.000000000 +0300
@@ -252,7 +252,11 @@
struct pci_dev * _RP lis_osif_pci_find_class(unsigned int class,
struct pci_dev *from)
{
- return(pci_find_class(class, from)) ;
+ /*
+ * According to Documentation/pci.txt, pci_find_class() is superceded
+ * by pci_get_class()
+ */
+ return(pci_get_class(class, from)) ;
}
struct pci_dev * _RP lis_osif_pci_find_slot(unsigned int bus, unsigned int devfn)
@@ -388,13 +392,21 @@
void _RP lis_osif_pci_dma_sync_single(struct pci_dev *hwdev,
dma_addr_t dma_handle, size_t size, int direction)
{
- pci_dma_sync_single(hwdev, dma_handle, size, direction) ;
+ /*
+ * pci_dma_sync_single macro is obsolete.
+ * pci_dma_sync_single_for_cpu should be used directly
+ */
+ pci_dma_sync_single_for_cpu(hwdev, dma_handle, size, direction) ;
}
void _RP lis_osif_pci_dma_sync_sg(struct pci_dev *hwdev,
struct scatterlist *sg, int nelems, int direction)
{
- pci_dma_sync_sg(hwdev, sg, nelems, direction) ;
+ /*
+ * pci_dma_sync_sg macro is obsolete.
+ * pci_dma_sync_sg_for_cpu should be used directly
+ */
+ pci_dma_sync_sg_for_cpu(hwdev, sg, nelems, direction) ;
}
int _RP lis_osif_pci_dma_supported(struct pci_dev *hwdev, u64 mask)