From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80]) by finch.gentoo.org (Postfix) with ESMTP id CB91B1381F3 for ; Mon, 10 Jun 2013 16:35:19 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id 5EF39E08D9; Mon, 10 Jun 2013 16:35:19 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [140.211.166.183]) (using TLSv1 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by pigeon.gentoo.org (Postfix) with ESMTPS id D7A44E08D9 for ; Mon, 10 Jun 2013 16:35:18 +0000 (UTC) Received: from hornbill.gentoo.org (hornbill.gentoo.org [94.100.119.163]) (using TLSv1 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id 0DED133DF46 for ; Mon, 10 Jun 2013 16:35:17 +0000 (UTC) Received: from localhost.localdomain (localhost [127.0.0.1]) by hornbill.gentoo.org (Postfix) with ESMTP id A1BD7E468F for ; Mon, 10 Jun 2013 16:35:15 +0000 (UTC) From: "Emil Karlson" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Emil Karlson" Message-ID: <1370882046.d08f145e6dbc13796fddf39c41467a87dfb4db35.emil_karlson@gentoo> Subject: [gentoo-commits] proj/x11:master commit in: x11-drivers/ati-drivers/, x11-drivers/ati-drivers/files/ X-VCS-Repository: proj/x11 X-VCS-Files: x11-drivers/ati-drivers/ati-drivers-13.6_beta.ebuild x11-drivers/ati-drivers/files/ati-drivers-13.6-linux-3.10-proc.diff X-VCS-Directories: x11-drivers/ati-drivers/ x11-drivers/ati-drivers/files/ X-VCS-Committer: emil_karlson X-VCS-Committer-Name: Emil Karlson X-VCS-Revision: d08f145e6dbc13796fddf39c41467a87dfb4db35 X-VCS-Branch: master Date: Mon, 10 Jun 2013 16:35:15 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Archives-Salt: aaf7704b-1f2a-4e99-877c-96ae51d94284 X-Archives-Hash: 80813c8e57b9bd1a22872e04abf94c1f commit: d08f145e6dbc13796fddf39c41467a87dfb4db35 Author: Emil Karlson gmail com> AuthorDate: Mon Jun 10 16:34:06 2013 +0000 Commit: Emil Karlson gmail com> CommitDate: Mon Jun 10 16:34:06 2013 +0000 URL: http://git.overlays.gentoo.org/gitweb/?p=proj/x11.git;a=commit;h=d08f145e x11-drivers/ati-drivers: port linux-3.10-proc.diff to 13.6_beta --- .../ati-drivers/ati-drivers-13.6_beta.ebuild | 2 +- .../files/ati-drivers-13.6-linux-3.10-proc.diff | 356 +++++++++++++++++++++ 2 files changed, 357 insertions(+), 1 deletion(-) diff --git a/x11-drivers/ati-drivers/ati-drivers-13.6_beta.ebuild b/x11-drivers/ati-drivers/ati-drivers-13.6_beta.ebuild index 0fe8a6f..5c856fc 100644 --- a/x11-drivers/ati-drivers/ati-drivers-13.6_beta.ebuild +++ b/x11-drivers/ati-drivers/ati-drivers-13.6_beta.ebuild @@ -315,7 +315,7 @@ src_prepare() { # Compile fix for kernel typesafe uid types #469160 epatch "${FILESDIR}/linux-3.9-kuid.diff" - epatch "${FILESDIR}/linux-3.10-proc.diff" + epatch "${FILESDIR}/ati-drivers-13.6-linux-3.10-proc.diff" # Compile fix, https://bugs.gentoo.org/show_bug.cgi?id=454870 use pax_kernel && epatch "${FILESDIR}/const-notifier-block.patch" diff --git a/x11-drivers/ati-drivers/files/ati-drivers-13.6-linux-3.10-proc.diff b/x11-drivers/ati-drivers/files/ati-drivers-13.6-linux-3.10-proc.diff new file mode 100644 index 0000000..bdb22ea --- /dev/null +++ b/x11-drivers/ati-drivers/files/ati-drivers-13.6-linux-3.10-proc.diff @@ -0,0 +1,356 @@ +diff --git a/common/lib/modules/fglrx/build_mod/drmP.h b/common/lib/modules/fglrx/build_mod/drmP.h +index 81546b2..4e74526 100755 +--- a/common/lib/modules/fglrx/build_mod/drmP.h ++++ b/common/lib/modules/fglrx/build_mod/drmP.h +@@ -901,10 +901,6 @@ int DRM(stub_register)(const char *name, + int DRM(stub_unregister)(int minor); + + /* Proc support (drm_proc.h) */ +-extern struct proc_dir_entry *DRM(proc_init)(drm_device_t *dev, +- int minor, +- struct proc_dir_entry *root, +- struct proc_dir_entry **dev_root); + extern int DRM(proc_cleanup)(int minor, + struct proc_dir_entry *root, + struct proc_dir_entry *dev_root); +diff --git a/common/lib/modules/fglrx/build_mod/drm_proc.h b/common/lib/modules/fglrx/build_mod/drm_proc.h +index 1e3ab4a..c52ad7e 100755 +--- a/common/lib/modules/fglrx/build_mod/drm_proc.h ++++ b/common/lib/modules/fglrx/build_mod/drm_proc.h +@@ -75,61 +75,6 @@ struct drm_proc_list { + #define DRM_PROC_ENTRIES (sizeof(DRM(proc_list))/sizeof(DRM(proc_list)[0])) + + /** +- * Initialize the DRI proc filesystem for a device. +- * +- * \param dev DRM device. +- * \param minor device minor number. +- * \param root DRI proc dir entry. +- * \param dev_root resulting DRI device proc dir entry. +- * \return root entry pointer on success, or NULL on failure. +- * +- * Create the DRI proc root entry "/proc/ati", the device proc root entry +- * "/proc/ati/%minor%/", and each entry in proc_list as +- * "/proc/ati/%minor%/%name%". +- */ +-struct proc_dir_entry *DRM(proc_init)(drm_device_t *dev, int minor, +- struct proc_dir_entry *root, +- struct proc_dir_entry **dev_root) +-{ +- struct proc_dir_entry *ent; +- int i, j; +- char name[64]; +- +- if (!minor) root = create_proc_entry("dri", S_IFDIR, NULL); +- if (!root) { +- DRM_ERROR("Cannot create /proc/ati\n"); +- return NULL; +- } +- +- sprintf(name, "%d", minor); +- *dev_root = create_proc_entry(name, S_IFDIR, root); +- if (!*dev_root) { +- DRM_ERROR("Cannot create /proc/ati/%s\n", name); +- return NULL; +- } +- +- for (i = 0; i < DRM_PROC_ENTRIES; i++) { +- ent = create_proc_entry(DRM(proc_list)[i].name, +- S_IFREG|S_IRUGO, *dev_root); +- if (!ent) { +- DRM_ERROR("Cannot create /proc/ati/%s/%s\n", +- name, DRM(proc_list)[i].name); +- for (j = 0; j < i; j++) +- remove_proc_entry(DRM(proc_list)[i].name, +- *dev_root); +- remove_proc_entry(name, root); +- if (!minor) remove_proc_entry("dri", NULL); +- return NULL; +- } +- ent->read_proc = DRM(proc_list)[i].f; +- ent->data = dev; +- } +- +- return root; +-} +- +- +-/** + * Cleanup the proc filesystem resources. + * + * \param minor device minor number. +diff --git a/common/lib/modules/fglrx/build_mod/firegl_public.c b/common/lib/modules/fglrx/build_mod/firegl_public.c +index d3ad3ce..890a0aa 100755 +--- a/common/lib/modules/fglrx/build_mod/firegl_public.c ++++ b/common/lib/modules/fglrx/build_mod/firegl_public.c +@@ -583,6 +583,202 @@ kcl_proc_list_t KCL_PROC_FileList[] = + { "NULL", NULL, NULL} // Terminate List!!! + }; + ++ ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0) ++typedef int (read_proc_t)(char *page, char **start, off_t off, int count, int *eof, void *data); ++typedef int (write_proc_t)(struct file *file, const char __user *buffer, unsigned long count, void *data); ++#else ++#define PDE_DATA(inode) (PDE((inode))->data) ++#endif ++ ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0) ++typedef struct { ++ read_proc_t *read_func; ++ write_proc_t *write_func; ++ void *data; ++} gentoo_proc_wrapper_t; ++ ++#define GENTOO_PROC_WRAPPER_OVERFLOW_MAGIC 939750305 ++ ++static ssize_t gentoo_proc_wrapper_read (struct file *myfile, char __user *buffer, size_t count, loff_t *offset) { ++ int is_eof=0, retval; ++ char *start, *usebuffer=NULL; ++ gentoo_proc_wrapper_t* wrapper_data=(gentoo_proc_wrapper_t*)(myfile->private_data); ++ if (PAGE_SIZE<*offset) { ++ printk(KERN_ERR "Trying to read beyond 4k on proc\n"); ++ return -EIO; ++ } ++ //printk(KERN_NOTICE " call with: dev %p, func %p\n", wrapper_data->data, wrapper_data->read_func); ++ ++ usebuffer=kmalloc(2*PAGE_SIZE, GFP_KERNEL); ++ if (!usebuffer) ++ return -ENOMEM; ++ ((u32*)usebuffer)[1024]=GENTOO_PROC_WRAPPER_OVERFLOW_MAGIC; ++ ++ retval=wrapper_data->read_func(usebuffer, &start, *offset, count, &is_eof, wrapper_data->data); ++ ++ BUG_ON(GENTOO_PROC_WRAPPER_OVERFLOW_MAGIC != ((u32*)usebuffer)[1024]); ++ ++ if (0 > retval) ++ { ++ printk(KERN_ERR "Proc read failed with %d", retval); ++ goto out; ++ } ++ ++ if (copy_to_user(buffer, start, retval)) { ++ printk(KERN_NOTICE "copy to user failed in amd drivers proc code\n"); ++ retval=-EFAULT; ++ goto out; ++ } ++ *offset+=retval; ++ ++out: ++ if (usebuffer) ++ kfree(usebuffer); ++ return retval; ++} ++static ssize_t gentoo_proc_wrapper_write (struct file *myfile, const char __user *buffer, size_t count, loff_t *offset) { ++ gentoo_proc_wrapper_t* wrapper_data=(gentoo_proc_wrapper_t*)(myfile->private_data); ++ int retval=0; ++ void *usebuffer=NULL; ++ ++ BUG_ON(*offset); ++ if (!wrapper_data->write_func) ++ return -EPERM; ++ ++ usebuffer=kmalloc(count, GFP_KERNEL); ++ if (!usebuffer) ++ return -ENOMEM; ++ if (copy_from_user(usebuffer, buffer, count)) { ++ printk(KERN_NOTICE "copy from user failed in amd drivers proc code\n"); ++ retval=-EFAULT; ++ goto out; ++ } ++ ++ retval=wrapper_data->write_func(myfile, buffer, count, wrapper_data->data); ++ *offset+=retval; ++out: ++ if (usebuffer) ++ kfree(usebuffer); ++ return retval; ++} ++static int gentoo_proc_wrapper_open(struct inode *myinode, struct file *myfile) { ++ myfile->private_data=PDE_DATA(myinode); ++ return generic_file_open(myinode, myfile); ++} ++struct file_operations gentoo_proc_fops = { ++ .read=gentoo_proc_wrapper_read, ++ .write=gentoo_proc_wrapper_write, ++ .open=gentoo_proc_wrapper_open, ++}; ++ ++static void *gentoo_proc_wrapper_data(read_proc_t *reader, write_proc_t *writer, void *mydata) { ++ gentoo_proc_wrapper_t *retval=kmalloc(sizeof(gentoo_proc_wrapper_t), GFP_KERNEL); ++ if (!retval) ++ return retval; ++ retval->read_func=reader; ++ retval->write_func=writer; ++ retval->data=mydata; ++ return retval; ++} ++ ++static struct proc_dir_entry *firegl_proc_init( device_t *dev, ++ int minor, ++ struct proc_dir_entry *root, ++ struct proc_dir_entry **dev_root, ++ kcl_proc_list_t *proc_list ) // proc_list must be terminated! ++{ ++ struct proc_dir_entry *ent; ++ char name[64]; ++ kcl_proc_list_t *list = proc_list; ++ void *tempdata; ++ KCL_DEBUG1(FN_FIREGL_PROC, "minor %d, proc_list 0x%08lx\n", minor, (unsigned long)proc_list); ++ if (!minor) ++ { ++ root = proc_mkdir("ati", NULL); ++ } ++ ++ if (!root) ++ { ++ KCL_DEBUG_ERROR("Cannot create /proc/ati\n"); ++ return NULL; ++ } ++ ++ if (minor == 0) ++ { ++ // Global major debice number entry ++ tempdata=gentoo_proc_wrapper_data((read_proc_t*)firegl_major_proc_read, NULL, NULL); ++ if (!tempdata) ++ return NULL; ++ ent = proc_create_data("major", S_IFREG|S_IRUGO, root, &gentoo_proc_fops, tempdata); ++ if (!ent) ++ { ++ remove_proc_entry("ati", NULL); ++ KCL_DEBUG_ERROR("Cannot create /proc/ati/major\n"); ++ return NULL; ++ } ++ } ++ ++ sprintf(name, "%d", minor); ++ *dev_root = proc_mkdir(name, root); ++ if (!*dev_root) { ++ remove_proc_entry("major", root); ++ remove_proc_entry("ati", NULL); ++ KCL_DEBUG_ERROR("Cannot create /proc/ati/%s\n", name); ++ return NULL; ++ } ++ ++ while (list->f || list->fops) ++ { ++ struct file_operations *my_fops = &gentoo_proc_fops; ++ if (list->fops) ++ { ++ my_fops = (struct file_operations*)list->fops; ++ tempdata=(dev->pubdev.signature == FGL_DEVICE_SIGNATURE)? firegl_find_device(minor) : (dev); ++ } ++ else { ++ BUG_ON(!list->f); ++ tempdata=gentoo_proc_wrapper_data((read_proc_t*)list->f, NULL, (dev->pubdev.signature == FGL_DEVICE_SIGNATURE)? firegl_find_device(minor) : (dev) ); ++ if (!tempdata) ++ return NULL; ++ } ++ //printk(KERN_NOTICE "name %s, dev %p, func %p, data %p\n", list->name, (dev->pubdev.signature == FGL_DEVICE_SIGNATURE)? firegl_find_device(minor) : (dev), list->f, tempdata); ++ ent = proc_create_data(list->name, S_IFREG|S_IRUGO, *dev_root, my_fops, tempdata); ++ ++ if (!ent) ++ { ++ KCL_DEBUG_ERROR("Cannot create /proc/ati/%s/%s\n", name, list->name); ++ while (proc_list != list) ++ { ++ remove_proc_entry(proc_list->name, *dev_root); ++ proc_list++; ++ } ++ remove_proc_entry(name, root); ++ if (!minor) ++ { ++ remove_proc_entry("major", root); ++ remove_proc_entry("ati", NULL); ++ } ++ return NULL; ++ } ++ ++ list++; ++ } ++ ++ if (minor == 0) ++ { ++ // Global debug entry, only create it once ++ tempdata=gentoo_proc_wrapper_data((read_proc_t*)firegl_debug_proc_read_wrap, (write_proc_t*)firegl_debug_proc_write_wrap, dev); ++ if (!tempdata) ++ return NULL; ++ ent=proc_create_data("debug", S_IFREG|S_IRUGO, root, &gentoo_proc_fops, tempdata); ++ if (!ent) ++ return NULL; ++ } ++ ++ return root; ++} ++#else + static struct proc_dir_entry *firegl_proc_init( device_t *dev, + int minor, + struct proc_dir_entry *root, +@@ -677,6 +873,7 @@ static struct proc_dir_entry *firegl_proc_init( device_t *dev, + + return root; + } ++#endif + + static int firegl_proc_cleanup( int minor, + struct proc_dir_entry *root, +@@ -6135,59 +6332,4 @@ void ATI_API_CALL KCL_fpu_end(void) + kernel_fpu_end(); + } + +-/** Create new directory entry under "/proc/ati/...." +- * Where +- * root_dir - Root directory. If NULL then we should use "/proc/ati" root. +- * name - Pointer to the name of directory +- * access - Access attribute. We could use it to disable access to the directory for everybody accept owner. +- * By default owner is root. +- * Return NULL if failure. Pointer to proc_dir_entry otherwise +- */ +-void * KCL_create_proc_dir(void *root_dir, const char *name, unsigned int access) +-{ +- struct proc_dir_entry *dir = NULL; +- +- if (root_dir == NULL) +- dir = create_proc_entry(name, S_IFDIR | access, firegl_stub_root); +- else +- dir = create_proc_entry(name, S_IFDIR | access, (struct proc_dir_entry *)root_dir); +- +- return dir; +-} +- +-/* Remove proc directory entry +- * root - Pointer to directory proc entry or NULL if for "/proc/ati" +- * name - Name to delete +- */ +-void KCL_remove_proc_dir_entry(void *root, const char *name) +-{ +- if (root == NULL) +- remove_proc_entry(name, firegl_stub_root); +- else +- remove_proc_entry(name, (struct proc_dir_entry *)root); +-} +- +- +-/* Create proc_entry under "root_dir" +- * read_fn - Function which will be called on read request +- * write_fn - Function which will be called on write request +- * private_data - Pointer to private data which will be passed +- */ +-void KCL_create_proc_entry(void *root_dir, const char *name, unsigned int access_mode, void *read_fn, void *write_fn, void *private_data) +-{ +- struct proc_dir_entry *ent = NULL; +- +- if (root_dir == NULL || name == NULL) +- return; +- +- ent = create_proc_entry(name, access_mode, (struct proc_dir_entry *)root_dir); +- +- if (ent) +- { +- ent->read_proc = (read_proc_t *)read_fn; +- ent->write_proc = (write_proc_t *)write_fn; +- ent->data = private_data; +- } +-} +- + #endif /* __KERNEL__ */