Merge branch 'ppc-fixes' of git://git.bocc.de/dbox2 into for-2.6.24
[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, loff_t *foffset)
55 {
56         unsigned long limit = current->signal->rlim[RLIMIT_CORE].rlim_cur;
57         ssize_t written;
58
59         if (*foffset + nr > limit)
60                 return -EIO;
61
62         written = file->f_op->write(file, addr, nr, &file->f_pos);
63         *foffset += written;
64
65         if (written != nr)
66                 return -EIO;
67
68         return 0;
69 }
70
71 static int spufs_dump_align(struct file *file, char *buf, loff_t new_off,
72                             loff_t *foffset)
73 {
74         int rc, size;
75
76         size = min((loff_t)PAGE_SIZE, new_off - *foffset);
77         memset(buf, 0, size);
78
79         rc = 0;
80         while (rc == 0 && new_off > *foffset) {
81                 size = min((loff_t)PAGE_SIZE, new_off - *foffset);
82                 rc = spufs_dump_write(file, buf, size, foffset);
83         }
84
85         return rc;
86 }
87
88 static int spufs_ctx_note_size(struct spu_context *ctx, int dfd)
89 {
90         int i, sz, total = 0;
91         char *name;
92         char fullname[80];
93
94         for (i = 0; spufs_coredump_read[i].name != NULL; i++) {
95                 name = spufs_coredump_read[i].name;
96                 sz = spufs_coredump_read[i].size;
97
98                 sprintf(fullname, "SPU/%d/%s", dfd, name);
99
100                 total += sizeof(struct elf_note);
101                 total += roundup(strlen(fullname) + 1, 4);
102                 total += roundup(sz, 4);
103         }
104
105         return total;
106 }
107
108 /*
109  * The additional architecture-specific notes for Cell are various
110  * context files in the spu context.
111  *
112  * This function iterates over all open file descriptors and sees
113  * if they are a directory in spufs.  In that case we use spufs
114  * internal functionality to dump them without needing to actually
115  * open the files.
116  */
117 static struct spu_context *coredump_next_context(int *fd)
118 {
119         struct fdtable *fdt = files_fdtable(current->files);
120         struct file *file;
121         struct spu_context *ctx = NULL;
122
123         for (; *fd < fdt->max_fds; (*fd)++) {
124                 if (!FD_ISSET(*fd, fdt->open_fds))
125                         continue;
126
127                 file = fcheck(*fd);
128
129                 if (!file || file->f_op != &spufs_context_fops)
130                         continue;
131
132                 ctx = SPUFS_I(file->f_dentry->d_inode)->i_ctx;
133                 if (ctx->flags & SPU_CREATE_NOSCHED)
134                         continue;
135
136                 /* start searching the next fd next time we're called */
137                 (*fd)++;
138                 break;
139         }
140
141         return ctx;
142 }
143
144 int spufs_coredump_extra_notes_size(void)
145 {
146         struct spu_context *ctx;
147         int size = 0, rc, fd;
148
149         fd = 0;
150         while ((ctx = coredump_next_context(&fd)) != NULL) {
151                 spu_acquire_saved(ctx);
152                 rc = spufs_ctx_note_size(ctx, fd);
153                 spu_release_saved(ctx);
154                 if (rc < 0)
155                         break;
156
157                 size += rc;
158         }
159
160         return size;
161 }
162
163 static int spufs_arch_write_note(struct spu_context *ctx, int i,
164                                   struct file *file, int dfd, loff_t *foffset)
165 {
166         loff_t pos = 0;
167         int sz, rc, nread, total = 0;
168         const int bufsz = PAGE_SIZE;
169         char *name;
170         char fullname[80], *buf;
171         struct elf_note en;
172
173         buf = (void *)get_zeroed_page(GFP_KERNEL);
174         if (!buf)
175                 return -ENOMEM;
176
177         name = spufs_coredump_read[i].name;
178         sz = spufs_coredump_read[i].size;
179
180         sprintf(fullname, "SPU/%d/%s", dfd, name);
181         en.n_namesz = strlen(fullname) + 1;
182         en.n_descsz = sz;
183         en.n_type = NT_SPU;
184
185         rc = spufs_dump_write(file, &en, sizeof(en), foffset);
186         if (rc)
187                 goto out;
188
189         rc = spufs_dump_write(file, fullname, en.n_namesz, foffset);
190         if (rc)
191                 goto out;
192
193         rc = spufs_dump_align(file, buf, roundup(*foffset, 4), foffset);
194         if (rc)
195                 goto out;
196
197         do {
198                 nread = do_coredump_read(i, ctx, buf, bufsz, &pos);
199                 if (nread > 0) {
200                         rc = spufs_dump_write(file, buf, nread, foffset);
201                         if (rc)
202                                 goto out;
203                         total += nread;
204                 }
205         } while (nread == bufsz && total < sz);
206
207         if (nread < 0) {
208                 rc = nread;
209                 goto out;
210         }
211
212         rc = spufs_dump_align(file, buf, roundup(*foffset - total + sz, 4),
213                               foffset);
214
215 out:
216         free_page((unsigned long)buf);
217         return rc;
218 }
219
220 int spufs_coredump_extra_notes_write(struct file *file, loff_t *foffset)
221 {
222         struct spu_context *ctx;
223         int fd, j, rc;
224
225         fd = 0;
226         while ((ctx = coredump_next_context(&fd)) != NULL) {
227                 spu_acquire_saved(ctx);
228
229                 for (j = 0; spufs_coredump_read[j].name != NULL; j++) {
230                         rc = spufs_arch_write_note(ctx, j, file, fd, foffset);
231                         if (rc) {
232                                 spu_release_saved(ctx);
233                                 return rc;
234                         }
235                 }
236
237                 spu_release_saved(ctx);
238         }
239
240         return 0;
241 }