Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux-2.6 (b22793f7) · Commits · 戴 / test

arch/ia64/Kconfig

+10 −2

Original line number	Diff line number	Diff line
		@@ -53,6 +53,9 @@ config MMU
		bool
		default y

		config ARCH_DMA_ADDR_T_64BIT
		def_bool y

		config NEED_DMA_MAP_STATE
		def_bool y

		@@ -62,6 +65,9 @@ config NEED_SG_DMA_LENGTH
		config SWIOTLB
		bool

		config STACKTRACE_SUPPORT
		def_bool y

		config GENERIC_LOCKBREAK
		def_bool n

		@@ -683,8 +689,10 @@ source "lib/Kconfig"
		# Use the generic interrupt handling code in kernel/irq/:
		#
		config GENERIC_HARDIRQS
		bool
		default y
		def_bool y

		config GENERIC_HARDIRQS_NO__DO_IRQ
		def_bool y

		config GENERIC_IRQ_PROBE
		bool

arch/ia64/include/asm/compat.h

deleted100644 → 0

+0 −208

Original line number	Diff line number	Diff line
		#ifndef _ASM_IA64_COMPAT_H
		#define _ASM_IA64_COMPAT_H
		/*
		* Architecture specific compatibility types
		*/
		#include <linux/types.h>

		#define COMPAT_USER_HZ 100
		#define COMPAT_UTS_MACHINE "i686\0\0\0"

		typedef u32 compat_size_t;
		typedef s32 compat_ssize_t;
		typedef s32 compat_time_t;
		typedef s32 compat_clock_t;
		typedef s32 compat_key_t;
		typedef s32 compat_pid_t;
		typedef u16 __compat_uid_t;
		typedef u16 __compat_gid_t;
		typedef u32 __compat_uid32_t;
		typedef u32 __compat_gid32_t;
		typedef u16 compat_mode_t;
		typedef u32 compat_ino_t;
		typedef u16 compat_dev_t;
		typedef s32 compat_off_t;
		typedef s64 compat_loff_t;
		typedef u16 compat_nlink_t;
		typedef u16 compat_ipc_pid_t;
		typedef s32 compat_daddr_t;
		typedef u32 compat_caddr_t;
		typedef __kernel_fsid_t compat_fsid_t;
		typedef s32 compat_timer_t;

		typedef s32 compat_int_t;
		typedef s32 compat_long_t;
		typedef s64 __attribute__((aligned(4))) compat_s64;
		typedef u32 compat_uint_t;
		typedef u32 compat_ulong_t;
		typedef u64 __attribute__((aligned(4))) compat_u64;

		struct compat_timespec {
		compat_time_t tv_sec;
		s32 tv_nsec;
		};

		struct compat_timeval {
		compat_time_t tv_sec;
		s32 tv_usec;
		};

		struct compat_stat {
		compat_dev_t st_dev;
		u16 __pad1;
		compat_ino_t st_ino;
		compat_mode_t st_mode;
		compat_nlink_t st_nlink;
		__compat_uid_t st_uid;
		__compat_gid_t st_gid;
		compat_dev_t st_rdev;
		u16 __pad2;
		u32 st_size;
		u32 st_blksize;
		u32 st_blocks;
		u32 st_atime;
		u32 st_atime_nsec;
		u32 st_mtime;
		u32 st_mtime_nsec;
		u32 st_ctime;
		u32 st_ctime_nsec;
		u32 __unused4;
		u32 __unused5;
		};

		struct compat_flock {
		short l_type;
		short l_whence;
		compat_off_t l_start;
		compat_off_t l_len;
		compat_pid_t l_pid;
		};

		#define F_GETLK64 12
		#define F_SETLK64 13
		#define F_SETLKW64 14

		/*
		* IA32 uses 4 byte alignment for 64 bit quantities,
		* so we need to pack this structure.
		*/
		struct compat_flock64 {
		short l_type;
		short l_whence;
		compat_loff_t l_start;
		compat_loff_t l_len;
		compat_pid_t l_pid;
		} __attribute__((packed));

		struct compat_statfs {
		int f_type;
		int f_bsize;
		int f_blocks;
		int f_bfree;
		int f_bavail;
		int f_files;
		int f_ffree;
		compat_fsid_t f_fsid;
		int f_namelen; /* SunOS ignores this field. */
		int f_frsize;
		int f_spare[5];
		};

		#define COMPAT_RLIM_OLD_INFINITY 0x7fffffff
		#define COMPAT_RLIM_INFINITY 0xffffffff

		typedef u32 compat_old_sigset_t; /* at least 32 bits */

		#define _COMPAT_NSIG 64
		#define _COMPAT_NSIG_BPW 32

		typedef u32 compat_sigset_word;

		#define COMPAT_OFF_T_MAX 0x7fffffff
		#define COMPAT_LOFF_T_MAX 0x7fffffffffffffffL

		struct compat_ipc64_perm {
		compat_key_t key;
		__compat_uid32_t uid;
		__compat_gid32_t gid;
		__compat_uid32_t cuid;
		__compat_gid32_t cgid;
		unsigned short mode;
		unsigned short __pad1;
		unsigned short seq;
		unsigned short __pad2;
		compat_ulong_t unused1;
		compat_ulong_t unused2;
		};

		struct compat_semid64_ds {
		struct compat_ipc64_perm sem_perm;
		compat_time_t sem_otime;
		compat_ulong_t __unused1;
		compat_time_t sem_ctime;
		compat_ulong_t __unused2;
		compat_ulong_t sem_nsems;
		compat_ulong_t __unused3;
		compat_ulong_t __unused4;
		};

		struct compat_msqid64_ds {
		struct compat_ipc64_perm msg_perm;
		compat_time_t msg_stime;
		compat_ulong_t __unused1;
		compat_time_t msg_rtime;
		compat_ulong_t __unused2;
		compat_time_t msg_ctime;
		compat_ulong_t __unused3;
		compat_ulong_t msg_cbytes;
		compat_ulong_t msg_qnum;
		compat_ulong_t msg_qbytes;
		compat_pid_t msg_lspid;
		compat_pid_t msg_lrpid;
		compat_ulong_t __unused4;
		compat_ulong_t __unused5;
		};

		struct compat_shmid64_ds {
		struct compat_ipc64_perm shm_perm;
		compat_size_t shm_segsz;
		compat_time_t shm_atime;
		compat_ulong_t __unused1;
		compat_time_t shm_dtime;
		compat_ulong_t __unused2;
		compat_time_t shm_ctime;
		compat_ulong_t __unused3;
		compat_pid_t shm_cpid;
		compat_pid_t shm_lpid;
		compat_ulong_t shm_nattch;
		compat_ulong_t __unused4;
		compat_ulong_t __unused5;
		};

		/*
		* A pointer passed in from user mode. This should not be used for syscall parameters,
		* just declare them as pointers because the syscall entry code will have appropriately
		* converted them already.
		*/
		typedef u32 compat_uptr_t;

		static inline void __user *
		compat_ptr (compat_uptr_t uptr)
		{
		return (void __user *) (unsigned long) uptr;
		}

		static inline compat_uptr_t
		ptr_to_compat(void __user *uptr)
		{
		return (u32)(unsigned long)uptr;
		}

		static __inline__ void __user *
		arch_compat_alloc_user_space (long len)
		{
		struct pt_regs *regs = task_pt_regs(current);
		return (void __user *) (((regs->r12 & 0xffffffff) & -16) - len);
		}

		#endif /* _ASM_IA64_COMPAT_H */

arch/ia64/kernel/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -34,6 +34,7 @@ obj-$(CONFIG_AUDIT) += audit.o
		obj-$(CONFIG_PCI_MSI) += msi_ia64.o
		mca_recovery-y += mca_drv.o mca_drv_asm.o
		obj-$(CONFIG_IA64_MC_ERR_INJECT)+= err_inject.o
		obj-$(CONFIG_STACKTRACE) += stacktrace.o

		obj-$(CONFIG_PARAVIRT) += paravirt.o paravirtentry.o \
		paravirt_patch.o

arch/ia64/kernel/cyclone.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -59,13 +59,13 @@ int __init init_cyclone_clock(void)
		return -ENODEV;
		}
		base = readq(reg);
		iounmap(reg);
		if(!base){
		printk(KERN_ERR "Summit chipset: Could not find valid CBAR"
		" value.\n");
		use_cyclone = 0;
		return -ENODEV;
		}
		iounmap(reg);

		/* setup PMCC */
		offset = (base + CYCLONE_PMCC_OFFSET);

arch/ia64/kernel/iosapic.c

+9 −51

Original line number	Diff line number	Diff line
		@@ -108,10 +108,6 @@
		#define DBG(fmt...)
		#endif

		#define NR_PREALLOCATE_RTE_ENTRIES \
		(PAGE_SIZE / sizeof(struct iosapic_rte_info))
		#define RTE_PREALLOCATED (1)

		static DEFINE_SPINLOCK(iosapic_lock);

		/*
		@@ -136,7 +132,6 @@ struct iosapic_rte_info {
		struct list_head rte_list; /* RTEs sharing the same vector */
		char rte_index; /* IOSAPIC RTE index */
		int refcnt; /* reference counter */
		unsigned int flags; /* flags */
		struct iosapic *iosapic;
		} ____cacheline_aligned;

		@@ -155,9 +150,6 @@ static struct iosapic_intr_info {

		static unsigned char pcat_compat __devinitdata; /* 8259 compatibility flag */

		static int iosapic_kmalloc_ok;
		static LIST_HEAD(free_rte_list);

		static inline void
		iosapic_write(struct iosapic *iosapic, unsigned int reg, u32 val)
		{
		@@ -394,7 +386,7 @@ iosapic_startup_level_irq (unsigned int irq)
		}

		static void
		iosapic_end_level_irq (unsigned int irq)
		iosapic_unmask_level_irq (unsigned int irq)
		{
		ia64_vector vec = irq_to_vector(irq);
		struct iosapic_rte_info *rte;
		@@ -404,7 +396,8 @@ iosapic_end_level_irq (unsigned int irq)
		if (unlikely(irq_desc[irq].status & IRQ_MOVE_PENDING)) {
		do_unmask_irq = 1;
		mask_irq(irq);
		}
		} else
		unmask_irq(irq);

		list_for_each_entry(rte, &iosapic_intr_info[irq].rtes, rte_list)
		iosapic_eoi(rte->iosapic->addr, vec);
		@@ -427,9 +420,8 @@ static struct irq_chip irq_type_iosapic_level = {
		.enable = iosapic_enable_level_irq,
		.disable = iosapic_disable_level_irq,
		.ack = iosapic_ack_level_irq,
		.end = iosapic_end_level_irq,
		.mask = mask_irq,
		.unmask = unmask_irq,
		.unmask = iosapic_unmask_level_irq,
		.set_affinity = iosapic_set_affinity
		};

		@@ -552,37 +544,6 @@ iosapic_reassign_vector (int irq)
		}
		}

		static struct iosapic_rte_info * __init_refok iosapic_alloc_rte (void)
		{
		int i;
		struct iosapic_rte_info *rte;
		int preallocated = 0;

		if (!iosapic_kmalloc_ok && list_empty(&free_rte_list)) {
		rte = alloc_bootmem(sizeof(struct iosapic_rte_info) *
		NR_PREALLOCATE_RTE_ENTRIES);
		for (i = 0; i < NR_PREALLOCATE_RTE_ENTRIES; i++, rte++)
		list_add(&rte->rte_list, &free_rte_list);
		}

		if (!list_empty(&free_rte_list)) {
		rte = list_entry(free_rte_list.next, struct iosapic_rte_info,
		rte_list);
		list_del(&rte->rte_list);
		preallocated++;
		} else {
		rte = kmalloc(sizeof(struct iosapic_rte_info), GFP_ATOMIC);
		if (!rte)
		return NULL;
		}

		memset(rte, 0, sizeof(struct iosapic_rte_info));
		if (preallocated)
		rte->flags \|= RTE_PREALLOCATED;

		return rte;
		}

		static inline int irq_is_shared (int irq)
		{
		return (iosapic_intr_info[irq].count > 1);
		@@ -615,7 +576,7 @@ register_intr (unsigned int gsi, int irq, unsigned char delivery,

		rte = find_rte(irq, gsi);
		if (!rte) {
		rte = iosapic_alloc_rte();
		rte = kzalloc(sizeof (*rte), GFP_ATOMIC);
		if (!rte) {
		printk(KERN_WARNING "%s: cannot allocate memory\n",
		__func__);
		@@ -658,6 +619,10 @@ register_intr (unsigned int gsi, int irq, unsigned char delivery,
		idesc->chip->name, irq_type->name);
		idesc->chip = irq_type;
		}
		if (trigger == IOSAPIC_EDGE)
		__set_irq_handler_unlocked(irq, handle_edge_irq);
		else
		__set_irq_handler_unlocked(irq, handle_level_irq);
		return 0;
		}

		@@ -1161,10 +1126,3 @@ map_iosapic_to_node(unsigned int gsi_base, int node)
		return;
		}
		#endif

		static int __init iosapic_enable_kmalloc (void)
		{
		iosapic_kmalloc_ok = 1;
		return 0;
		}
		core_initcall (iosapic_enable_kmalloc);

Admin message