Attachment #104026 for bug #158119

View | Details | Raw Unified | Return to bug 158119
Collapse All | Expand All





// ============================================================
#include <linux/version.h>
#include <linux/utsrelease.h>
#ifdef MODVERSIONS
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,71)
#include <linux/modversions.h>

                __KE_DEBUG(REMAP_PAGE_RANGE_STR " failed\n");
                return -EAGAIN;
            }
            vma->vm_flags |= VM_RESERVED; /* Don't swap */
            vma->vm_ops = &vm_ops;
            }
			break;

        case __KE_SHM:
            vma->vm_flags |= VM_RESERVED; /* Don't swap */
            vma->vm_ops = &vm_shm_ops;
            break;


            pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;

#if LINUX_VERSION_CODE <= 0x02040e /* KERNEL_VERSION(2,4,14) */
            vma->vm_flags |= VM_LOCKED; /* Don't swap */
#else
            vma->vm_flags |= VM_RESERVED;
#endif

            //vma->vm_flags |= VM_LOCKED; /* DDDDDDDDDDon't swap */
            //vma->vm_mm->locked_vm += pages; /* Kernel tracks aqmount of locked pages */
            vma->vm_ops = &vm_pcie_ops;
            break;

        case __KE_CTX:
            pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
            vma->vm_flags |= VM_LOCKED | VM_RESERVED; /* Don't swap */
            vma->vm_mm->locked_vm += pages; /* Kernel tracks aqmount of locked pages */
            vma->vm_ops = &vm_ctx_ops;
            break;

        case __KE_PCI_BQS:
            pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
            vma->vm_flags |= VM_LOCKED | VM_RESERVED; /* Don't swap */
            vma->vm_mm->locked_vm += pages; /* Kernel tracks aqmount of locked pages */
            vma->vm_ops = &vm_pci_bq_ops;
            break;

                 * with sorting out the real physical pages and mappings
                 * in our page fault handler
                 */
                vma->vm_flags |= VM_RESERVED; /* Don't swap */
                vma->vm_ops = &vm_cant_ops;
            }
#else

#ifdef __x86_64__
                vma->vm_flags |= VM_RESERVED;
#else
                vma->vm_flags |= VM_RESERVED; /* Don't swap */
#endif
                vma->vm_ops = &vm_ops;
            }

                 * with sorting out the real physical pages and mappings
                 * in our page fault handler
                 */
                vma->vm_flags |= VM_RESERVED; /* Don't swap */
                vma->vm_ops = &vm_cant_agp_bq_ops;
            }
            // else

#ifdef __x86_64__
                vma->vm_flags |= VM_RESERVED;
#else
                vma->vm_flags |= VM_RESERVED; /* Don't swap */
#endif
                vma->vm_ops = &vm_agp_bq_ops;
            }

#endif /* __AGP__BUILTIN__ */

        case __KE_KMAP:
		    vma->vm_flags |= VM_RESERVED;
            vma->vm_ops = &vm_kmap_ops;
            if (readonly && (vma->vm_flags & VM_WRITE))
            {

Lines 205-211 Link Here

(-)common.orig/lib/modules/fglrx/build_mod/make.sh (-1 / +1 lines)
205		205
206	# verify match with respective line in linux/version.h	206	# verify match with respective line in linux/version.h
207	# sample: #define UTS_RELEASE "2.4.0-test7"	207	# sample: #define UTS_RELEASE "2.4.0-test7"
208	src_file=$linuxincludes/linux/version.h	208	src_file=$linuxincludes/linux/utsrelease.h
209	if [ ! -e $src_file ];	209	if [ ! -e $src_file ];
210	then	210	then
211	echo "kernel includes at $linuxincludes not found or incomplete" \| tee -a $logfile	211	echo "kernel includes at $linuxincludes not found or incomplete" \| tee -a $logfile

Return to bug 158119

Lines 23-28 Link Here

(-)common.orig/lib/modules/fglrx/build_mod/firegl_public.c (-11 / +12 lines)
23		23
24	// ============================================================	24	// ============================================================
25	#include <linux/version.h>	25	#include <linux/version.h>
		26	#include <linux/utsrelease.h>
26	#ifdef MODVERSIONS	27	#ifdef MODVERSIONS
27	#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,71)	28	#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,71)
28	#include <linux/modversions.h>	29	#include <linux/modversions.h>
Lines 3156-3168 Link Here
3156	__KE_DEBUG(REMAP_PAGE_RANGE_STR " failed\n");	3157	__KE_DEBUG(REMAP_PAGE_RANGE_STR " failed\n");
3157	return -EAGAIN;	3158	return -EAGAIN;
3158	}	3159	}
3159	vma->vm_flags \|= VM_SHM \| VM_RESERVED; /* Don't swap */	3160	vma->vm_flags \|= VM_RESERVED; /* Don't swap */
3160	vma->vm_ops = &vm_ops;	3161	vma->vm_ops = &vm_ops;
3161	}	3162	}
3162	break;	3163	break;
3163		3164
3164	case __KE_SHM:	3165	case __KE_SHM:
3165	vma->vm_flags \|= VM_SHM \| VM_RESERVED; /* Don't swap */	3166	vma->vm_flags \|= VM_RESERVED; /* Don't swap */
3166	vma->vm_ops = &vm_shm_ops;	3167	vma->vm_ops = &vm_shm_ops;
3167	break;	3168	break;
3168		3169
Lines 3171-3196 Link Here
3171	pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;	3172	pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
3172		3173
3173	#if LINUX_VERSION_CODE <= 0x02040e /* KERNEL_VERSION(2,4,14) */	3174	#if LINUX_VERSION_CODE <= 0x02040e /* KERNEL_VERSION(2,4,14) */
3174	vma->vm_flags \|= VM_LOCKED \| VM_SHM; /* Don't swap */	3175	vma->vm_flags \|= VM_LOCKED; /* Don't swap */
3175	#else	3176	#else
3176	vma->vm_flags \|= VM_RESERVED;	3177	vma->vm_flags \|= VM_RESERVED;
3177	#endif	3178	#endif
3178		3179
3179	//vma->vm_flags \|= VM_SHM \| VM_LOCKED; /* DDDDDDDDDDon't swap */	3180	//vma->vm_flags \|= VM_LOCKED; /* DDDDDDDDDDon't swap */
3180	//vma->vm_mm->locked_vm += pages; /* Kernel tracks aqmount of locked pages */	3181	//vma->vm_mm->locked_vm += pages; /* Kernel tracks aqmount of locked pages */
3181	vma->vm_ops = &vm_pcie_ops;	3182	vma->vm_ops = &vm_pcie_ops;
3182	break;	3183	break;
3183		3184
3184	case __KE_CTX:	3185	case __KE_CTX:
3185	pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;	3186	pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
3186	vma->vm_flags \|= VM_LOCKED \| VM_SHM \| VM_RESERVED; /* Don't swap */	3187	vma->vm_flags \|= VM_LOCKED \| VM_RESERVED; /* Don't swap */
3187	vma->vm_mm->locked_vm += pages; /* Kernel tracks aqmount of locked pages */	3188	vma->vm_mm->locked_vm += pages; /* Kernel tracks aqmount of locked pages */
3188	vma->vm_ops = &vm_ctx_ops;	3189	vma->vm_ops = &vm_ctx_ops;
3189	break;	3190	break;
3190		3191
3191	case __KE_PCI_BQS:	3192	case __KE_PCI_BQS:
3192	pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;	3193	pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
3193	vma->vm_flags \|= VM_LOCKED \| VM_SHM \| VM_RESERVED; /* Don't swap */	3194	vma->vm_flags \|= VM_LOCKED \| VM_RESERVED; /* Don't swap */
3194	vma->vm_mm->locked_vm += pages; /* Kernel tracks aqmount of locked pages */	3195	vma->vm_mm->locked_vm += pages; /* Kernel tracks aqmount of locked pages */
3195	vma->vm_ops = &vm_pci_bq_ops;	3196	vma->vm_ops = &vm_pci_bq_ops;
3196	break;	3197	break;
Lines 3206-3212 Link Here
3206	* with sorting out the real physical pages and mappings	3207	* with sorting out the real physical pages and mappings
3207	* in our page fault handler	3208	* in our page fault handler
3208	*/	3209	*/
3209	vma->vm_flags \|= VM_SHM \| VM_RESERVED; /* Don't swap */	3210	vma->vm_flags \|= VM_RESERVED; /* Don't swap */
3210	vma->vm_ops = &vm_cant_ops;	3211	vma->vm_ops = &vm_cant_ops;
3211	}	3212	}
3212	#else	3213	#else
Lines 3222-3228 Link Here
3222	#ifdef __x86_64__	3223	#ifdef __x86_64__
3223	vma->vm_flags \|= VM_RESERVED;	3224	vma->vm_flags \|= VM_RESERVED;
3224	#else	3225	#else
3225	vma->vm_flags \|= VM_SHM \| VM_RESERVED; /* Don't swap */	3226	vma->vm_flags \|= VM_RESERVED; /* Don't swap */
3226	#endif	3227	#endif
3227	vma->vm_ops = &vm_ops;	3228	vma->vm_ops = &vm_ops;
3228	}	3229	}
Lines 3238-3244 Link Here
3238	* with sorting out the real physical pages and mappings	3239	* with sorting out the real physical pages and mappings
3239	* in our page fault handler	3240	* in our page fault handler
3240	*/	3241	*/
3241	vma->vm_flags \|= VM_SHM \| VM_RESERVED; /* Don't swap */	3242	vma->vm_flags \|= VM_RESERVED; /* Don't swap */
3242	vma->vm_ops = &vm_cant_agp_bq_ops;	3243	vma->vm_ops = &vm_cant_agp_bq_ops;
3243	}	3244	}
3244	// else	3245	// else
Lines 3254-3260 Link Here
3254	#ifdef __x86_64__	3255	#ifdef __x86_64__
3255	vma->vm_flags \|= VM_RESERVED;	3256	vma->vm_flags \|= VM_RESERVED;
3256	#else	3257	#else
3257	vma->vm_flags \|= VM_SHM \| VM_RESERVED; /* Don't swap */	3258	vma->vm_flags \|= VM_RESERVED; /* Don't swap */
3258	#endif	3259	#endif
3259	vma->vm_ops = &vm_agp_bq_ops;	3260	vma->vm_ops = &vm_agp_bq_ops;
3260	}	3261	}
Lines 3263-3269 Link Here
3263	#endif /* __AGP__BUILTIN__ */	3264	#endif /* __AGP__BUILTIN__ */
3264		3265
3265	case __KE_KMAP:	3266	case __KE_KMAP:
3266	vma->vm_flags \|= VM_SHM \| VM_RESERVED;	3267	vma->vm_flags \|= VM_RESERVED;
3267	vma->vm_ops = &vm_kmap_ops;	3268	vma->vm_ops = &vm_kmap_ops;
3268	if (readonly && (vma->vm_flags & VM_WRITE))	3269	if (readonly && (vma->vm_flags & VM_WRITE))
3269	{	3270	{