ecryptfs: use memdup_user()
[linux-2.6.git] / arch / arm / kernel / sys_oabi-compat.c
1 /*
2  *  arch/arm/kernel/sys_oabi-compat.c
3  *
4  *  Compatibility wrappers for syscalls that are used from
5  *  old ABI user space binaries with an EABI kernel.
6  *
7  *  Author:     Nicolas Pitre
8  *  Created:    Oct 7, 2005
9  *  Copyright:  MontaVista Software, Inc.
10  *
11  *  This program is free software; you can redistribute it and/or modify
12  *  it under the terms of the GNU General Public License version 2 as
13  *  published by the Free Software Foundation.
14  */
15
16 /*
17  * The legacy ABI and the new ARM EABI have different rules making some
18  * syscalls incompatible especially with structure arguments.
19  * Most notably, Eabi says 64-bit members should be 64-bit aligned instead of
20  * simply word aligned.  EABI also pads structures to the size of the largest
21  * member it contains instead of the invariant 32-bit.
22  *
23  * The following syscalls are affected:
24  *
25  * sys_stat64:
26  * sys_lstat64:
27  * sys_fstat64:
28  * sys_fstatat64:
29  *
30  *   struct stat64 has different sizes and some members are shifted
31  *   Compatibility wrappers are needed for them and provided below.
32  *
33  * sys_fcntl64:
34  *
35  *   struct flock64 has different sizes and some members are shifted
36  *   A compatibility wrapper is needed and provided below.
37  *
38  * sys_statfs64:
39  * sys_fstatfs64:
40  *
41  *   struct statfs64 has extra padding with EABI growing its size from
42  *   84 to 88.  This struct is now __attribute__((packed,aligned(4)))
43  *   with a small assembly wrapper to force the sz argument to 84 if it is 88
44  *   to avoid copying the extra padding over user space unexpecting it.
45  *
46  * sys_newuname:
47  *
48  *   struct new_utsname has no padding with EABI.  No problem there.
49  *
50  * sys_epoll_ctl:
51  * sys_epoll_wait:
52  *
53  *   struct epoll_event has its second member shifted also affecting the
54  *   structure size. Compatibility wrappers are needed and provided below.
55  *
56  * sys_ipc:
57  * sys_semop:
58  * sys_semtimedop:
59  *
60  *   struct sembuf loses its padding with EABI.  Since arrays of them are
61  *   used they have to be copyed to remove the padding. Compatibility wrappers
62  *   provided below.
63  *
64  * sys_bind:
65  * sys_connect:
66  * sys_sendmsg:
67  * sys_sendto:
68  * sys_socketcall:
69  *
70  *   struct sockaddr_un loses its padding with EABI.  Since the size of the
71  *   structure is used as a validation test in unix_mkname(), we need to
72  *   change the length argument to 110 whenever it is 112.  Compatibility
73  *   wrappers provided below.
74  */
75
76 #include <linux/syscalls.h>
77 #include <linux/errno.h>
78 #include <linux/fs.h>
79 #include <linux/fcntl.h>
80 #include <linux/eventpoll.h>
81 #include <linux/sem.h>
82 #include <linux/socket.h>
83 #include <linux/net.h>
84 #include <linux/ipc.h>
85 #include <linux/uaccess.h>
86 #include <linux/slab.h>
87
88 struct oldabi_stat64 {
89         unsigned long long st_dev;
90         unsigned int    __pad1;
91         unsigned long   __st_ino;
92         unsigned int    st_mode;
93         unsigned int    st_nlink;
94
95         unsigned long   st_uid;
96         unsigned long   st_gid;
97
98         unsigned long long st_rdev;
99         unsigned int    __pad2;
100
101         long long       st_size;
102         unsigned long   st_blksize;
103         unsigned long long st_blocks;
104
105         unsigned long   st_atime;
106         unsigned long   st_atime_nsec;
107
108         unsigned long   st_mtime;
109         unsigned long   st_mtime_nsec;
110
111         unsigned long   st_ctime;
112         unsigned long   st_ctime_nsec;
113
114         unsigned long long st_ino;
115 } __attribute__ ((packed,aligned(4)));
116
117 static long cp_oldabi_stat64(struct kstat *stat,
118                              struct oldabi_stat64 __user *statbuf)
119 {
120         struct oldabi_stat64 tmp;
121
122         tmp.st_dev = huge_encode_dev(stat->dev);
123         tmp.__pad1 = 0;
124         tmp.__st_ino = stat->ino;
125         tmp.st_mode = stat->mode;
126         tmp.st_nlink = stat->nlink;
127         tmp.st_uid = stat->uid;
128         tmp.st_gid = stat->gid;
129         tmp.st_rdev = huge_encode_dev(stat->rdev);
130         tmp.st_size = stat->size;
131         tmp.st_blocks = stat->blocks;
132         tmp.__pad2 = 0;
133         tmp.st_blksize = stat->blksize;
134         tmp.st_atime = stat->atime.tv_sec;
135         tmp.st_atime_nsec = stat->atime.tv_nsec;
136         tmp.st_mtime = stat->mtime.tv_sec;
137         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
138         tmp.st_ctime = stat->ctime.tv_sec;
139         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
140         tmp.st_ino = stat->ino;
141         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
142 }
143
144 asmlinkage long sys_oabi_stat64(char __user * filename,
145                                 struct oldabi_stat64 __user * statbuf)
146 {
147         struct kstat stat;
148         int error = vfs_stat(filename, &stat);
149         if (!error)
150                 error = cp_oldabi_stat64(&stat, statbuf);
151         return error;
152 }
153
154 asmlinkage long sys_oabi_lstat64(char __user * filename,
155                                  struct oldabi_stat64 __user * statbuf)
156 {
157         struct kstat stat;
158         int error = vfs_lstat(filename, &stat);
159         if (!error)
160                 error = cp_oldabi_stat64(&stat, statbuf);
161         return error;
162 }
163
164 asmlinkage long sys_oabi_fstat64(unsigned long fd,
165                                  struct oldabi_stat64 __user * statbuf)
166 {
167         struct kstat stat;
168         int error = vfs_fstat(fd, &stat);
169         if (!error)
170                 error = cp_oldabi_stat64(&stat, statbuf);
171         return error;
172 }
173
174 asmlinkage long sys_oabi_fstatat64(int dfd,
175                                    char __user *filename,
176                                    struct oldabi_stat64  __user *statbuf,
177                                    int flag)
178 {
179         struct kstat stat;
180         int error = -EINVAL;
181
182         if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
183                 goto out;
184
185         if (flag & AT_SYMLINK_NOFOLLOW)
186                 error = vfs_lstat_fd(dfd, filename, &stat);
187         else
188                 error = vfs_stat_fd(dfd, filename, &stat);
189
190         if (!error)
191         error = cp_oldabi_stat64(&stat, statbuf);
192
193 out:
194         return error;
195 }
196
197 struct oabi_flock64 {
198         short   l_type;
199         short   l_whence;
200         loff_t  l_start;
201         loff_t  l_len;
202         pid_t   l_pid;
203 } __attribute__ ((packed,aligned(4)));
204
205 asmlinkage long sys_oabi_fcntl64(unsigned int fd, unsigned int cmd,
206                                  unsigned long arg)
207 {
208         struct oabi_flock64 user;
209         struct flock64 kernel;
210         mm_segment_t fs = USER_DS; /* initialized to kill a warning */
211         unsigned long local_arg = arg;
212         int ret;
213
214         switch (cmd) {
215         case F_GETLK64:
216         case F_SETLK64:
217         case F_SETLKW64:
218                 if (copy_from_user(&user, (struct oabi_flock64 __user *)arg,
219                                    sizeof(user)))
220                         return -EFAULT;
221                 kernel.l_type   = user.l_type;
222                 kernel.l_whence = user.l_whence;
223                 kernel.l_start  = user.l_start;
224                 kernel.l_len    = user.l_len;
225                 kernel.l_pid    = user.l_pid;
226                 local_arg = (unsigned long)&kernel;
227                 fs = get_fs();
228                 set_fs(KERNEL_DS);
229         }
230
231         ret = sys_fcntl64(fd, cmd, local_arg);
232
233         switch (cmd) {
234         case F_GETLK64:
235                 if (!ret) {
236                         user.l_type     = kernel.l_type;
237                         user.l_whence   = kernel.l_whence;
238                         user.l_start    = kernel.l_start;
239                         user.l_len      = kernel.l_len;
240                         user.l_pid      = kernel.l_pid;
241                         if (copy_to_user((struct oabi_flock64 __user *)arg,
242                                          &user, sizeof(user)))
243                                 ret = -EFAULT;
244                 }
245         case F_SETLK64:
246         case F_SETLKW64:
247                 set_fs(fs);
248         }
249
250         return ret;
251 }
252
253 struct oabi_epoll_event {
254         __u32 events;
255         __u64 data;
256 } __attribute__ ((packed,aligned(4)));
257
258 asmlinkage long sys_oabi_epoll_ctl(int epfd, int op, int fd,
259                                    struct oabi_epoll_event __user *event)
260 {
261         struct oabi_epoll_event user;
262         struct epoll_event kernel;
263         mm_segment_t fs;
264         long ret;
265
266         if (op == EPOLL_CTL_DEL)
267                 return sys_epoll_ctl(epfd, op, fd, NULL);
268         if (copy_from_user(&user, event, sizeof(user)))
269                 return -EFAULT;
270         kernel.events = user.events;
271         kernel.data   = user.data;
272         fs = get_fs();
273         set_fs(KERNEL_DS);
274         ret = sys_epoll_ctl(epfd, op, fd, &kernel);
275         set_fs(fs);
276         return ret;
277 }
278
279 asmlinkage long sys_oabi_epoll_wait(int epfd,
280                                     struct oabi_epoll_event __user *events,
281                                     int maxevents, int timeout)
282 {
283         struct epoll_event *kbuf;
284         mm_segment_t fs;
285         long ret, err, i;
286
287         if (maxevents <= 0 || maxevents > (INT_MAX/sizeof(struct epoll_event)))
288                 return -EINVAL;
289         kbuf = kmalloc(sizeof(*kbuf) * maxevents, GFP_KERNEL);
290         if (!kbuf)
291                 return -ENOMEM;
292         fs = get_fs();
293         set_fs(KERNEL_DS);
294         ret = sys_epoll_wait(epfd, kbuf, maxevents, timeout);
295         set_fs(fs);
296         err = 0;
297         for (i = 0; i < ret; i++) {
298                 __put_user_error(kbuf[i].events, &events->events, err);
299                 __put_user_error(kbuf[i].data,   &events->data,   err);
300                 events++;
301         }
302         kfree(kbuf);
303         return err ? -EFAULT : ret;
304 }
305
306 struct oabi_sembuf {
307         unsigned short  sem_num;
308         short           sem_op;
309         short           sem_flg;
310         unsigned short  __pad;
311 };
312
313 asmlinkage long sys_oabi_semtimedop(int semid,
314                                     struct oabi_sembuf __user *tsops,
315                                     unsigned nsops,
316                                     const struct timespec __user *timeout)
317 {
318         struct sembuf *sops;
319         struct timespec local_timeout;
320         long err;
321         int i;
322
323         if (nsops < 1)
324                 return -EINVAL;
325         sops = kmalloc(sizeof(*sops) * nsops, GFP_KERNEL);
326         if (!sops)
327                 return -ENOMEM;
328         err = 0;
329         for (i = 0; i < nsops; i++) {
330                 __get_user_error(sops[i].sem_num, &tsops->sem_num, err);
331                 __get_user_error(sops[i].sem_op,  &tsops->sem_op,  err);
332                 __get_user_error(sops[i].sem_flg, &tsops->sem_flg, err);
333                 tsops++;
334         }
335         if (timeout) {
336                 /* copy this as well before changing domain protection */
337                 err |= copy_from_user(&local_timeout, timeout, sizeof(*timeout));
338                 timeout = &local_timeout;
339         }
340         if (err) {
341                 err = -EFAULT;
342         } else {
343                 mm_segment_t fs = get_fs();
344                 set_fs(KERNEL_DS);
345                 err = sys_semtimedop(semid, sops, nsops, timeout);
346                 set_fs(fs);
347         }
348         kfree(sops);
349         return err;
350 }
351
352 asmlinkage long sys_oabi_semop(int semid, struct oabi_sembuf __user *tsops,
353                                unsigned nsops)
354 {
355         return sys_oabi_semtimedop(semid, tsops, nsops, NULL);
356 }
357
358 extern asmlinkage int sys_ipc(uint call, int first, int second, int third,
359                               void __user *ptr, long fifth);
360
361 asmlinkage int sys_oabi_ipc(uint call, int first, int second, int third,
362                             void __user *ptr, long fifth)
363 {
364         switch (call & 0xffff) {
365         case SEMOP:
366                 return  sys_oabi_semtimedop(first,
367                                             (struct oabi_sembuf __user *)ptr,
368                                             second, NULL);
369         case SEMTIMEDOP:
370                 return  sys_oabi_semtimedop(first,
371                                             (struct oabi_sembuf __user *)ptr,
372                                             second,
373                                             (const struct timespec __user *)fifth);
374         default:
375                 return sys_ipc(call, first, second, third, ptr, fifth);
376         }
377 }
378
379 asmlinkage long sys_oabi_bind(int fd, struct sockaddr __user *addr, int addrlen)
380 {
381         sa_family_t sa_family;
382         if (addrlen == 112 &&
383             get_user(sa_family, &addr->sa_family) == 0 &&
384             sa_family == AF_UNIX)
385                         addrlen = 110;
386         return sys_bind(fd, addr, addrlen);
387 }
388
389 asmlinkage long sys_oabi_connect(int fd, struct sockaddr __user *addr, int addrlen)
390 {
391         sa_family_t sa_family;
392         if (addrlen == 112 &&
393             get_user(sa_family, &addr->sa_family) == 0 &&
394             sa_family == AF_UNIX)
395                         addrlen = 110;
396         return sys_connect(fd, addr, addrlen);
397 }
398
399 asmlinkage long sys_oabi_sendto(int fd, void __user *buff,
400                                 size_t len, unsigned flags,
401                                 struct sockaddr __user *addr,
402                                 int addrlen)
403 {
404         sa_family_t sa_family;
405         if (addrlen == 112 &&
406             get_user(sa_family, &addr->sa_family) == 0 &&
407             sa_family == AF_UNIX)
408                         addrlen = 110;
409         return sys_sendto(fd, buff, len, flags, addr, addrlen);
410 }
411
412 asmlinkage long sys_oabi_sendmsg(int fd, struct msghdr __user *msg, unsigned flags)
413 {
414         struct sockaddr __user *addr;
415         int msg_namelen;
416         sa_family_t sa_family;
417         if (msg &&
418             get_user(msg_namelen, &msg->msg_namelen) == 0 &&
419             msg_namelen == 112 &&
420             get_user(addr, &msg->msg_name) == 0 &&
421             get_user(sa_family, &addr->sa_family) == 0 &&
422             sa_family == AF_UNIX)
423         {
424                 /*
425                  * HACK ALERT: there is a limit to how much backward bending
426                  * we should do for what is actually a transitional
427                  * compatibility layer.  This already has known flaws with
428                  * a few ioctls that we don't intend to fix.  Therefore
429                  * consider this blatent hack as another one... and take care
430                  * to run for cover.  In most cases it will "just work fine".
431                  * If it doesn't, well, tough.
432                  */
433                 put_user(110, &msg->msg_namelen);
434         }
435         return sys_sendmsg(fd, msg, flags);
436 }
437
438 asmlinkage long sys_oabi_socketcall(int call, unsigned long __user *args)
439 {
440         unsigned long r = -EFAULT, a[6];
441
442         switch (call) {
443         case SYS_BIND:
444                 if (copy_from_user(a, args, 3 * sizeof(long)) == 0)
445                         r = sys_oabi_bind(a[0], (struct sockaddr __user *)a[1], a[2]);
446                 break;
447         case SYS_CONNECT:
448                 if (copy_from_user(a, args, 3 * sizeof(long)) == 0)
449                         r = sys_oabi_connect(a[0], (struct sockaddr __user *)a[1], a[2]);
450                 break;
451         case SYS_SENDTO:
452                 if (copy_from_user(a, args, 6 * sizeof(long)) == 0)
453                         r = sys_oabi_sendto(a[0], (void __user *)a[1], a[2], a[3],
454                                             (struct sockaddr __user *)a[4], a[5]);
455                 break;
456         case SYS_SENDMSG:
457                 if (copy_from_user(a, args, 3 * sizeof(long)) == 0)
458                         r = sys_oabi_sendmsg(a[0], (struct msghdr __user *)a[1], a[2]);
459                 break;
460         default:
461                 r = sys_socketcall(call, args);
462         }
463
464         return r;
465 }