[POWERPC] spufs: Combine spufs_coredump_calls with spufs_calls
[linux-2.6] / arch / powerpc / platforms / cell / spufs / coredump.c
1 /*
2  * SPU core dump code
3  *
4  * (C) Copyright 2006 IBM Corp.
5  *
6  * Author: Dwayne Grant McConnell <decimal@us.ibm.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2, or (at your option)
11  * any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  */
22
23 #include <linux/elf.h>
24 #include <linux/file.h>
25 #include <linux/fs.h>
26 #include <linux/list.h>
27 #include <linux/module.h>
28 #include <linux/syscalls.h>
29
30 #include <asm/uaccess.h>
31
32 #include "spufs.h"
33
34 static ssize_t do_coredump_read(int num, struct spu_context *ctx, void *buffer,
35                                 size_t size, loff_t *off)
36 {
37         u64 data;
38         int ret;
39
40         if (spufs_coredump_read[num].read)
41                 return spufs_coredump_read[num].read(ctx, buffer, size, off);
42
43         data = spufs_coredump_read[num].get(ctx);
44         ret = snprintf(buffer, size, "0x%.16lx", data);
45         if (ret >= size)
46                 return size;
47         return ++ret; /* count trailing NULL */
48 }
49
50 /*
51  * These are the only things you should do on a core-file: use only these
52  * functions to write out all the necessary info.
53  */
54 static int spufs_dump_write(struct file *file, const void *addr, int nr)
55 {
56         return file->f_op->write(file, addr, nr, &file->f_pos) == nr;
57 }
58
59 static int spufs_dump_seek(struct file *file, loff_t off)
60 {
61         if (file->f_op->llseek) {
62                 if (file->f_op->llseek(file, off, 0) != off)
63                         return 0;
64         } else
65                 file->f_pos = off;
66         return 1;
67 }
68
69 static int spufs_ctx_note_size(struct spu_context *ctx, int dfd)
70 {
71         int i, sz, total = 0;
72         char *name;
73         char fullname[80];
74
75         for (i = 0; spufs_coredump_read[i].name != NULL; i++) {
76                 name = spufs_coredump_read[i].name;
77                 sz = spufs_coredump_read[i].size;
78
79                 sprintf(fullname, "SPU/%d/%s", dfd, name);
80
81                 total += sizeof(struct elf_note);
82                 total += roundup(strlen(fullname) + 1, 4);
83                 total += roundup(sz, 4);
84         }
85
86         return total;
87 }
88
89 /*
90  * The additional architecture-specific notes for Cell are various
91  * context files in the spu context.
92  *
93  * This function iterates over all open file descriptors and sees
94  * if they are a directory in spufs.  In that case we use spufs
95  * internal functionality to dump them without needing to actually
96  * open the files.
97  */
98 static struct spu_context *coredump_next_context(int *fd)
99 {
100         struct fdtable *fdt = files_fdtable(current->files);
101         struct file *file;
102         struct spu_context *ctx = NULL;
103
104         for (; *fd < fdt->max_fds; (*fd)++) {
105                 if (!FD_ISSET(*fd, fdt->open_fds))
106                         continue;
107
108                 file = fcheck(*fd);
109
110                 if (!file || file->f_op != &spufs_context_fops)
111                         continue;
112
113                 ctx = SPUFS_I(file->f_dentry->d_inode)->i_ctx;
114                 if (ctx->flags & SPU_CREATE_NOSCHED)
115                         continue;
116
117                 /* start searching the next fd next time we're called */
118                 (*fd)++;
119                 break;
120         }
121
122         return ctx;
123 }
124
125 int spufs_coredump_extra_notes_size(void)
126 {
127         struct spu_context *ctx;
128         int size = 0, rc, fd;
129
130         fd = 0;
131         while ((ctx = coredump_next_context(&fd)) != NULL) {
132                 spu_acquire_saved(ctx);
133                 rc = spufs_ctx_note_size(ctx, fd);
134                 spu_release_saved(ctx);
135                 if (rc < 0)
136                         break;
137
138                 size += rc;
139         }
140
141         return size;
142 }
143
144 static void spufs_arch_write_note(struct spu_context *ctx, int i,
145                                 struct file *file, int dfd)
146 {
147         loff_t pos = 0;
148         int sz, rc, total = 0;
149         const int bufsz = PAGE_SIZE;
150         char *name;
151         char fullname[80], *buf;
152         struct elf_note en;
153
154         buf = (void *)get_zeroed_page(GFP_KERNEL);
155         if (!buf)
156                 return;
157
158         name = spufs_coredump_read[i].name;
159         sz = spufs_coredump_read[i].size;
160
161         sprintf(fullname, "SPU/%d/%s", dfd, name);
162         en.n_namesz = strlen(fullname) + 1;
163         en.n_descsz = sz;
164         en.n_type = NT_SPU;
165
166         if (!spufs_dump_write(file, &en, sizeof(en)))
167                 goto out;
168         if (!spufs_dump_write(file, fullname, en.n_namesz))
169                 goto out;
170         if (!spufs_dump_seek(file, roundup((unsigned long)file->f_pos, 4)))
171                 goto out;
172
173         do {
174                 rc = do_coredump_read(i, ctx, buf, bufsz, &pos);
175                 if (rc > 0) {
176                         if (!spufs_dump_write(file, buf, rc))
177                                 goto out;
178                         total += rc;
179                 }
180         } while (rc == bufsz && total < sz);
181
182         spufs_dump_seek(file, roundup((unsigned long)file->f_pos
183                                                 - total + sz, 4));
184 out:
185         free_page((unsigned long)buf);
186 }
187
188 void spufs_coredump_extra_notes_write(struct file *file)
189 {
190         struct spu_context *ctx;
191         int fd, j;
192
193         fd = 0;
194         while ((ctx = coredump_next_context(&fd)) != NULL) {
195                 spu_acquire_saved(ctx);
196
197                 for (j = 0; spufs_coredump_read[j].name != NULL; j++)
198                         spufs_arch_write_note(ctx, j, file, fd);
199
200                 spu_release_saved(ctx);
201         }
202 }