File: /usr/src/linux/arch/sparc64/solaris/fs.c
1 /* $Id: fs.c,v 1.25 2001/09/19 00:04:30 davem Exp $
2 * fs.c: fs related syscall emulation for Solaris
3 *
4 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
5 *
6 * 1999-08-19 Implemented solaris F_FREESP (truncate)
7 * fcntl, by Jason Rappleye (rappleye@ccr.buffalo.edu)
8 */
9
10 #include <linux/types.h>
11 #include <linux/sched.h>
12 #include <linux/slab.h>
13 #include <linux/fs.h>
14 #include <linux/mm.h>
15 #include <linux/file.h>
16 #include <linux/stat.h>
17 #include <linux/smp_lock.h>
18 #include <linux/limits.h>
19 #include <linux/resource.h>
20 #include <linux/quotaops.h>
21
22 #include <asm/uaccess.h>
23 #include <asm/string.h>
24 #include <asm/ptrace.h>
25
26 #include "conv.h"
27
28 #define R4_DEV(DEV) ((DEV & 0xff) | ((DEV & 0xff00) << 10))
29 #define R4_MAJOR(DEV) (((DEV) >> 18) & 0x3fff)
30 #define R4_MINOR(DEV) ((DEV) & 0x3ffff)
31 #define R3_VERSION 1
32 #define R4_VERSION 2
33
34 typedef struct {
35 s32 tv_sec;
36 s32 tv_nsec;
37 } timestruct_t;
38
39 struct sol_stat {
40 u32 st_dev;
41 s32 st_pad1[3]; /* network id */
42 u32 st_ino;
43 u32 st_mode;
44 u32 st_nlink;
45 u32 st_uid;
46 u32 st_gid;
47 u32 st_rdev;
48 s32 st_pad2[2];
49 s32 st_size;
50 s32 st_pad3; /* st_size, off_t expansion */
51 timestruct_t st_atime;
52 timestruct_t st_mtime;
53 timestruct_t st_ctime;
54 s32 st_blksize;
55 s32 st_blocks;
56 char st_fstype[16];
57 s32 st_pad4[8]; /* expansion area */
58 };
59
60 struct sol_stat64 {
61 u32 st_dev;
62 s32 st_pad1[3]; /* network id */
63 u64 st_ino;
64 u32 st_mode;
65 u32 st_nlink;
66 u32 st_uid;
67 u32 st_gid;
68 u32 st_rdev;
69 s32 st_pad2[2];
70 s64 st_size;
71 timestruct_t st_atime;
72 timestruct_t st_mtime;
73 timestruct_t st_ctime;
74 s64 st_blksize;
75 s32 st_blocks;
76 char st_fstype[16];
77 s32 st_pad4[4]; /* expansion area */
78 };
79
80 #define UFSMAGIC (((unsigned)'u'<<24)||((unsigned)'f'<<16)||((unsigned)'s'<<8))
81
82 static inline int putstat(struct sol_stat *ubuf, struct stat *kbuf)
83 {
84 if (put_user (R4_DEV(kbuf->st_dev), &ubuf->st_dev) ||
85 __put_user (kbuf->st_ino, &ubuf->st_ino) ||
86 __put_user (kbuf->st_mode, &ubuf->st_mode) ||
87 __put_user (kbuf->st_nlink, &ubuf->st_nlink) ||
88 __put_user (kbuf->st_uid, &ubuf->st_uid) ||
89 __put_user (kbuf->st_gid, &ubuf->st_gid) ||
90 __put_user (R4_DEV(kbuf->st_rdev), &ubuf->st_rdev) ||
91 __put_user (kbuf->st_size, &ubuf->st_size) ||
92 __put_user (kbuf->st_atime, &ubuf->st_atime.tv_sec) ||
93 __put_user (0, &ubuf->st_atime.tv_nsec) ||
94 __put_user (kbuf->st_mtime, &ubuf->st_mtime.tv_sec) ||
95 __put_user (0, &ubuf->st_mtime.tv_nsec) ||
96 __put_user (kbuf->st_ctime, &ubuf->st_ctime.tv_sec) ||
97 __put_user (0, &ubuf->st_ctime.tv_nsec) ||
98 __put_user (kbuf->st_blksize, &ubuf->st_blksize) ||
99 __put_user (kbuf->st_blocks, &ubuf->st_blocks) ||
100 __put_user (UFSMAGIC, (unsigned *)ubuf->st_fstype))
101 return -EFAULT;
102 return 0;
103 }
104
105 static inline int putstat64(struct sol_stat64 *ubuf, struct stat *kbuf)
106 {
107 if (put_user (R4_DEV(kbuf->st_dev), &ubuf->st_dev) ||
108 __put_user (kbuf->st_ino, &ubuf->st_ino) ||
109 __put_user (kbuf->st_mode, &ubuf->st_mode) ||
110 __put_user (kbuf->st_nlink, &ubuf->st_nlink) ||
111 __put_user (kbuf->st_uid, &ubuf->st_uid) ||
112 __put_user (kbuf->st_gid, &ubuf->st_gid) ||
113 __put_user (R4_DEV(kbuf->st_rdev), &ubuf->st_rdev) ||
114 __put_user (kbuf->st_size, &ubuf->st_size) ||
115 __put_user (kbuf->st_atime, &ubuf->st_atime.tv_sec) ||
116 __put_user (0, &ubuf->st_atime.tv_nsec) ||
117 __put_user (kbuf->st_mtime, &ubuf->st_mtime.tv_sec) ||
118 __put_user (0, &ubuf->st_mtime.tv_nsec) ||
119 __put_user (kbuf->st_ctime, &ubuf->st_ctime.tv_sec) ||
120 __put_user (0, &ubuf->st_ctime.tv_nsec) ||
121 __put_user (kbuf->st_blksize, &ubuf->st_blksize) ||
122 __put_user (kbuf->st_blocks, &ubuf->st_blocks) ||
123 __put_user (UFSMAGIC, (unsigned *)ubuf->st_fstype))
124 return -EFAULT;
125 return 0;
126 }
127
128 asmlinkage int solaris_stat(u32 filename, u32 statbuf)
129 {
130 int ret;
131 struct stat s;
132 char *filenam;
133 mm_segment_t old_fs = get_fs();
134 int (*sys_newstat)(char *,struct stat *) =
135 (int (*)(char *,struct stat *))SYS(stat);
136
137 filenam = getname ((char *)A(filename));
138 ret = PTR_ERR(filenam);
139 if (!IS_ERR(filenam)) {
140 set_fs (KERNEL_DS);
141 ret = sys_newstat(filenam, &s);
142 set_fs (old_fs);
143 putname (filenam);
144 if (putstat ((struct sol_stat *)A(statbuf), &s))
145 return -EFAULT;
146 }
147 return ret;
148 }
149
150 asmlinkage int solaris_xstat(int vers, u32 filename, u32 statbuf)
151 {
152 /* Solaris doesn't bother with looking at vers, so we do neither */
153 return solaris_stat(filename, statbuf);
154 }
155
156 asmlinkage int solaris_stat64(u32 filename, u32 statbuf)
157 {
158 int ret;
159 struct stat s;
160 char *filenam;
161 mm_segment_t old_fs = get_fs();
162 int (*sys_newstat)(char *,struct stat *) =
163 (int (*)(char *,struct stat *))SYS(stat);
164
165 filenam = getname ((char *)A(filename));
166 ret = PTR_ERR(filenam);
167 if (!IS_ERR(filenam)) {
168 set_fs (KERNEL_DS);
169 ret = sys_newstat(filenam, &s);
170 set_fs (old_fs);
171 putname (filenam);
172 if (putstat64 ((struct sol_stat64 *)A(statbuf), &s))
173 return -EFAULT;
174 }
175 return ret;
176 }
177
178 asmlinkage int solaris_lstat(u32 filename, u32 statbuf)
179 {
180 int ret;
181 struct stat s;
182 char *filenam;
183 mm_segment_t old_fs = get_fs();
184 int (*sys_newlstat)(char *,struct stat *) =
185 (int (*)(char *,struct stat *))SYS(lstat);
186
187 filenam = getname ((char *)A(filename));
188 ret = PTR_ERR(filenam);
189 if (!IS_ERR(filenam)) {
190 set_fs (KERNEL_DS);
191 ret = sys_newlstat(filenam, &s);
192 set_fs (old_fs);
193 putname (filenam);
194 if (putstat ((struct sol_stat *)A(statbuf), &s))
195 return -EFAULT;
196 }
197 return ret;
198 }
199
200 asmlinkage int solaris_lxstat(int vers, u32 filename, u32 statbuf)
201 {
202 return solaris_lstat(filename, statbuf);
203 }
204
205 asmlinkage int solaris_lstat64(u32 filename, u32 statbuf)
206 {
207 int ret;
208 struct stat s;
209 char *filenam;
210 mm_segment_t old_fs = get_fs();
211 int (*sys_newlstat)(char *,struct stat *) =
212 (int (*)(char *,struct stat *))SYS(lstat);
213
214 filenam = getname ((char *)A(filename));
215 ret = PTR_ERR(filenam);
216 if (!IS_ERR(filenam)) {
217 set_fs (KERNEL_DS);
218 ret = sys_newlstat(filenam, &s);
219 set_fs (old_fs);
220 putname (filenam);
221 if (putstat64 ((struct sol_stat64 *)A(statbuf), &s))
222 return -EFAULT;
223 }
224 return ret;
225 }
226
227 asmlinkage int solaris_fstat(unsigned int fd, u32 statbuf)
228 {
229 int ret;
230 struct stat s;
231 mm_segment_t old_fs = get_fs();
232 int (*sys_newfstat)(unsigned,struct stat *) =
233 (int (*)(unsigned,struct stat *))SYS(fstat);
234
235 set_fs (KERNEL_DS);
236 ret = sys_newfstat(fd, &s);
237 set_fs (old_fs);
238 if (putstat ((struct sol_stat *)A(statbuf), &s))
239 return -EFAULT;
240 return ret;
241 }
242
243 asmlinkage int solaris_fxstat(int vers, u32 fd, u32 statbuf)
244 {
245 return solaris_fstat(fd, statbuf);
246 }
247
248 asmlinkage int solaris_fstat64(unsigned int fd, u32 statbuf)
249 {
250 int ret;
251 struct stat s;
252 mm_segment_t old_fs = get_fs();
253 int (*sys_newfstat)(unsigned,struct stat *) =
254 (int (*)(unsigned,struct stat *))SYS(fstat);
255
256 set_fs (KERNEL_DS);
257 ret = sys_newfstat(fd, &s);
258 set_fs (old_fs);
259 if (putstat64 ((struct sol_stat64 *)A(statbuf), &s))
260 return -EFAULT;
261 return ret;
262 }
263
264 asmlinkage int solaris_mknod(u32 path, u32 mode, s32 dev)
265 {
266 int (*sys_mknod)(const char *,int,dev_t) =
267 (int (*)(const char *,int,dev_t))SYS(mknod);
268 int major, minor;
269
270 if ((major = R4_MAJOR(dev)) > 255 ||
271 (minor = R4_MINOR(dev)) > 255) return -EINVAL;
272 return sys_mknod((const char *)A(path), mode, MKDEV(major,minor));
273 }
274
275 asmlinkage int solaris_xmknod(int vers, u32 path, u32 mode, s32 dev)
276 {
277 return solaris_mknod(path, mode, dev);
278 }
279
280 asmlinkage int solaris_getdents64(unsigned int fd, void *dirent, unsigned int count)
281 {
282 int (*sys_getdents)(unsigned int, void *, unsigned int) =
283 (int (*)(unsigned int, void *, unsigned int))SYS(getdents);
284
285 return sys_getdents(fd, dirent, count);
286 }
287
288 /* This statfs thingie probably will go in the near future, but... */
289
290 struct sol_statfs {
291 short f_type;
292 s32 f_bsize;
293 s32 f_frsize;
294 s32 f_blocks;
295 s32 f_bfree;
296 u32 f_files;
297 u32 f_ffree;
298 char f_fname[6];
299 char f_fpack[6];
300 };
301
302 asmlinkage int solaris_statfs(u32 path, u32 buf, int len, int fstype)
303 {
304 int ret;
305 struct statfs s;
306 mm_segment_t old_fs = get_fs();
307 int (*sys_statfs)(const char *,struct statfs *) =
308 (int (*)(const char *,struct statfs *))SYS(statfs);
309 struct sol_statfs *ss = (struct sol_statfs *)A(buf);
310
311 if (len != sizeof(struct sol_statfs)) return -EINVAL;
312 if (!fstype) {
313 set_fs (KERNEL_DS);
314 ret = sys_statfs((const char *)A(path), &s);
315 set_fs (old_fs);
316 if (!ret) {
317 if (put_user (s.f_type, &ss->f_type) ||
318 __put_user (s.f_bsize, &ss->f_bsize) ||
319 __put_user (0, &ss->f_frsize) ||
320 __put_user (s.f_blocks, &ss->f_blocks) ||
321 __put_user (s.f_bfree, &ss->f_bfree) ||
322 __put_user (s.f_files, &ss->f_files) ||
323 __put_user (s.f_ffree, &ss->f_ffree) ||
324 __clear_user (&ss->f_fname, 12))
325 return -EFAULT;
326 }
327 return ret;
328 }
329 /* Linux can't stat unmounted filesystems so we
330 * simply lie and claim 100MB of 1GB is free. Sorry.
331 */
332 if (put_user (fstype, &ss->f_type) ||
333 __put_user (1024, &ss->f_bsize) ||
334 __put_user (0, &ss->f_frsize) ||
335 __put_user (1024*1024, &ss->f_blocks) ||
336 __put_user (100*1024, &ss->f_bfree) ||
337 __put_user (60000, &ss->f_files) ||
338 __put_user (50000, &ss->f_ffree) ||
339 __clear_user (&ss->f_fname, 12))
340 return -EFAULT;
341 return 0;
342 }
343
344 asmlinkage int solaris_fstatfs(u32 fd, u32 buf, int len, int fstype)
345 {
346 int ret;
347 struct statfs s;
348 mm_segment_t old_fs = get_fs();
349 int (*sys_fstatfs)(unsigned,struct statfs *) =
350 (int (*)(unsigned,struct statfs *))SYS(fstatfs);
351 struct sol_statfs *ss = (struct sol_statfs *)A(buf);
352
353 if (len != sizeof(struct sol_statfs)) return -EINVAL;
354 if (!fstype) {
355 set_fs (KERNEL_DS);
356 ret = sys_fstatfs(fd, &s);
357 set_fs (old_fs);
358 if (!ret) {
359 if (put_user (s.f_type, &ss->f_type) ||
360 __put_user (s.f_bsize, &ss->f_bsize) ||
361 __put_user (0, &ss->f_frsize) ||
362 __put_user (s.f_blocks, &ss->f_blocks) ||
363 __put_user (s.f_bfree, &ss->f_bfree) ||
364 __put_user (s.f_files, &ss->f_files) ||
365 __put_user (s.f_ffree, &ss->f_ffree) ||
366 __clear_user (&ss->f_fname, 12))
367 return -EFAULT;
368 }
369 return ret;
370 }
371 /* Otherwise fstatfs is the same as statfs */
372 return solaris_statfs(0, buf, len, fstype);
373 }
374
375 struct sol_statvfs {
376 u32 f_bsize;
377 u32 f_frsize;
378 u32 f_blocks;
379 u32 f_bfree;
380 u32 f_bavail;
381 u32 f_files;
382 u32 f_ffree;
383 u32 f_favail;
384 u32 f_fsid;
385 char f_basetype[16];
386 u32 f_flag;
387 u32 f_namemax;
388 char f_fstr[32];
389 u32 f_filler[16];
390 };
391
392 struct sol_statvfs64 {
393 u32 f_bsize;
394 u32 f_frsize;
395 u64 f_blocks;
396 u64 f_bfree;
397 u64 f_bavail;
398 u64 f_files;
399 u64 f_ffree;
400 u64 f_favail;
401 u32 f_fsid;
402 char f_basetype[16];
403 u32 f_flag;
404 u32 f_namemax;
405 char f_fstr[32];
406 u32 f_filler[16];
407 };
408
409 static int report_statvfs(struct vfsmount *mnt, struct inode *inode, u32 buf)
410 {
411 struct statfs s;
412 int error;
413 struct sol_statvfs *ss = (struct sol_statvfs *)A(buf);
414
415 error = vfs_statfs(mnt->mnt_sb, &s);
416 if (!error) {
417 const char *p = mnt->mnt_sb->s_type->name;
418 int i = 0;
419 int j = strlen (p);
420
421 if (j > 15) j = 15;
422 if (IS_RDONLY(inode)) i = 1;
423 if (mnt->mnt_flags & MNT_NOSUID) i |= 2;
424 if (put_user (s.f_bsize, &ss->f_bsize) ||
425 __put_user (0, &ss->f_frsize) ||
426 __put_user (s.f_blocks, &ss->f_blocks) ||
427 __put_user (s.f_bfree, &ss->f_bfree) ||
428 __put_user (s.f_bavail, &ss->f_bavail) ||
429 __put_user (s.f_files, &ss->f_files) ||
430 __put_user (s.f_ffree, &ss->f_ffree) ||
431 __put_user (s.f_ffree, &ss->f_favail) ||
432 __put_user (R4_DEV(inode->i_sb->s_dev), &ss->f_fsid) ||
433 __copy_to_user (ss->f_basetype,p,j) ||
434 __put_user (0, (char *)&ss->f_basetype[j]) ||
435 __put_user (s.f_namelen, &ss->f_namemax) ||
436 __put_user (i, &ss->f_flag) ||
437 __clear_user (&ss->f_fstr, 32))
438 return -EFAULT;
439 }
440 return error;
441 }
442
443 static int report_statvfs64(struct vfsmount *mnt, struct inode *inode, u32 buf)
444 {
445 struct statfs s;
446 int error;
447 struct sol_statvfs64 *ss = (struct sol_statvfs64 *)A(buf);
448
449 error = vfs_statfs(mnt->mnt_sb, &s);
450 if (!error) {
451 const char *p = mnt->mnt_sb->s_type->name;
452 int i = 0;
453 int j = strlen (p);
454
455 if (j > 15) j = 15;
456 if (IS_RDONLY(inode)) i = 1;
457 if (mnt->mnt_flags & MNT_NOSUID) i |= 2;
458 if (put_user (s.f_bsize, &ss->f_bsize) ||
459 __put_user (0, &ss->f_frsize) ||
460 __put_user (s.f_blocks, &ss->f_blocks) ||
461 __put_user (s.f_bfree, &ss->f_bfree) ||
462 __put_user (s.f_bavail, &ss->f_bavail) ||
463 __put_user (s.f_files, &ss->f_files) ||
464 __put_user (s.f_ffree, &ss->f_ffree) ||
465 __put_user (s.f_ffree, &ss->f_favail) ||
466 __put_user (R4_DEV(inode->i_sb->s_dev), &ss->f_fsid) ||
467 __copy_to_user (ss->f_basetype,p,j) ||
468 __put_user (0, (char *)&ss->f_basetype[j]) ||
469 __put_user (s.f_namelen, &ss->f_namemax) ||
470 __put_user (i, &ss->f_flag) ||
471 __clear_user (&ss->f_fstr, 32))
472 return -EFAULT;
473 }
474 return error;
475 }
476
477 asmlinkage int solaris_statvfs(u32 path, u32 buf)
478 {
479 struct nameidata nd;
480 int error;
481
482 error = user_path_walk((const char *)A(path),&nd);
483 if (!error) {
484 struct inode * inode = nd.dentry->d_inode;
485 error = report_statvfs(nd.mnt, inode, buf);
486 path_release(&nd);
487 }
488 return error;
489 }
490
491 asmlinkage int solaris_fstatvfs(unsigned int fd, u32 buf)
492 {
493 struct file * file;
494 int error;
495
496 error = -EBADF;
497 file = fget(fd);
498 if (file) {
499 error = report_statvfs(file->f_vfsmnt, file->f_dentry->d_inode, buf);
500 fput(file);
501 }
502
503 return error;
504 }
505
506 asmlinkage int solaris_statvfs64(u32 path, u32 buf)
507 {
508 struct nameidata nd;
509 int error;
510
511 lock_kernel();
512 error = user_path_walk((const char *)A(path), &nd);
513 if (!error) {
514 struct inode * inode = nd.dentry->d_inode;
515 error = report_statvfs64(nd.mnt, inode, buf);
516 path_release(&nd);
517 }
518 unlock_kernel();
519 return error;
520 }
521
522 asmlinkage int solaris_fstatvfs64(unsigned int fd, u32 buf)
523 {
524 struct file * file;
525 int error;
526
527 error = -EBADF;
528 file = fget(fd);
529 if (file) {
530 lock_kernel();
531 error = report_statvfs64(file->f_vfsmnt, file->f_dentry->d_inode, buf);
532 unlock_kernel();
533 fput(file);
534 }
535 return error;
536 }
537
538 extern asmlinkage long sparc32_open(const char * filename, int flags, int mode);
539
540 asmlinkage int solaris_open(u32 fname, int flags, u32 mode)
541 {
542 const char *filename = (const char *)(long)fname;
543 int fl = flags & 0xf;
544
545 /* Translate flags first. */
546 if (flags & 0x2000) fl |= O_LARGEFILE;
547 if (flags & 0x8050) fl |= O_SYNC;
548 if (flags & 0x80) fl |= O_NONBLOCK;
549 if (flags & 0x100) fl |= O_CREAT;
550 if (flags & 0x200) fl |= O_TRUNC;
551 if (flags & 0x400) fl |= O_EXCL;
552 if (flags & 0x800) fl |= O_NOCTTY;
553 flags = fl;
554
555 return sparc32_open(filename, flags, mode);
556 }
557
558 #define SOL_F_SETLK 6
559 #define SOL_F_SETLKW 7
560 #define SOL_F_FREESP 11
561 #define SOL_F_ISSTREAM 13
562 #define SOL_F_GETLK 14
563 #define SOL_F_PRIV 15
564 #define SOL_F_NPRIV 16
565 #define SOL_F_QUOTACTL 17
566 #define SOL_F_BLOCKS 18
567 #define SOL_F_BLKSIZE 19
568 #define SOL_F_GETOWN 23
569 #define SOL_F_SETOWN 24
570
571 struct sol_flock {
572 short l_type;
573 short l_whence;
574 u32 l_start;
575 u32 l_len;
576 s32 l_sysid;
577 s32 l_pid;
578 s32 l_pad[4];
579 };
580
581 asmlinkage int solaris_fcntl(unsigned fd, unsigned cmd, u32 arg)
582 {
583 int (*sys_fcntl)(unsigned,unsigned,unsigned long) =
584 (int (*)(unsigned,unsigned,unsigned long))SYS(fcntl);
585 int ret, flags;
586
587 switch (cmd) {
588 case F_DUPFD:
589 case F_GETFD:
590 case F_SETFD: return sys_fcntl(fd, cmd, (unsigned long)arg);
591 case F_GETFL:
592 flags = sys_fcntl(fd, cmd, 0);
593 ret = flags & 0xf;
594 if (flags & O_SYNC) ret |= 0x8050;
595 if (flags & O_NONBLOCK) ret |= 0x80;
596 return ret;
597 case F_SETFL:
598 flags = arg & 0xf;
599 if (arg & 0x8050) flags |= O_SYNC;
600 if (arg & 0x80) flags |= O_NONBLOCK;
601 return sys_fcntl(fd, cmd, (long)flags);
602 case SOL_F_GETLK:
603 case SOL_F_SETLK:
604 case SOL_F_SETLKW:
605 {
606 struct flock f;
607 mm_segment_t old_fs = get_fs();
608
609 switch (cmd) {
610 case SOL_F_GETLK: cmd = F_GETLK; break;
611 case SOL_F_SETLK: cmd = F_SETLK; break;
612 case SOL_F_SETLKW: cmd = F_SETLKW; break;
613 }
614
615 if (get_user (f.l_type, &((struct sol_flock *)A(arg))->l_type) ||
616 __get_user (f.l_whence, &((struct sol_flock *)A(arg))->l_whence) ||
617 __get_user (f.l_start, &((struct sol_flock *)A(arg))->l_start) ||
618 __get_user (f.l_len, &((struct sol_flock *)A(arg))->l_len) ||
619 __get_user (f.l_pid, &((struct sol_flock *)A(arg))->l_sysid))
620 return -EFAULT;
621
622 set_fs(KERNEL_DS);
623 ret = sys_fcntl(fd, cmd, (unsigned long)&f);
624 set_fs(old_fs);
625
626 if (__put_user (f.l_type, &((struct sol_flock *)A(arg))->l_type) ||
627 __put_user (f.l_whence, &((struct sol_flock *)A(arg))->l_whence) ||
628 __put_user (f.l_start, &((struct sol_flock *)A(arg))->l_start) ||
629 __put_user (f.l_len, &((struct sol_flock *)A(arg))->l_len) ||
630 __put_user (f.l_pid, &((struct sol_flock *)A(arg))->l_pid) ||
631 __put_user (0, &((struct sol_flock *)A(arg))->l_sysid))
632 return -EFAULT;
633
634 return ret;
635 }
636 case SOL_F_FREESP:
637 {
638 int length;
639 int (*sys_newftruncate)(unsigned int, unsigned long)=
640 (int (*)(unsigned int, unsigned long))SYS(ftruncate);
641
642 if (get_user(length, &((struct sol_flock*)A(arg))->l_start))
643 return -EFAULT;
644
645 return sys_newftruncate(fd, length);
646 }
647 };
648 return -EINVAL;
649 }
650
651 asmlinkage int solaris_ulimit(int cmd, int val)
652 {
653 switch (cmd) {
654 case 1: /* UL_GETFSIZE - in 512B chunks */
655 return current->rlim[RLIMIT_FSIZE].rlim_cur >> 9;
656 case 2: /* UL_SETFSIZE */
657 if ((unsigned long)val > (LONG_MAX>>9)) return -ERANGE;
658 val <<= 9;
659 lock_kernel();
660 if (val > current->rlim[RLIMIT_FSIZE].rlim_max) {
661 if (!capable(CAP_SYS_RESOURCE)) {
662 unlock_kernel();
663 return -EPERM;
664 }
665 current->rlim[RLIMIT_FSIZE].rlim_max = val;
666 }
667 current->rlim[RLIMIT_FSIZE].rlim_cur = val;
668 unlock_kernel();
669 return 0;
670 case 3: /* UL_GMEMLIM */
671 return current->rlim[RLIMIT_DATA].rlim_cur;
672 case 4: /* UL_GDESLIM */
673 return NR_OPEN;
674 }
675 return -EINVAL;
676 }
677
678 /* At least at the time I'm writing this, Linux doesn't have ACLs, so we
679 just fake this */
680 asmlinkage int solaris_acl(u32 filename, int cmd, int nentries, u32 aclbufp)
681 {
682 return -ENOSYS;
683 }
684
685 asmlinkage int solaris_facl(unsigned int fd, int cmd, int nentries, u32 aclbufp)
686 {
687 return -ENOSYS;
688 }
689
690 asmlinkage int solaris_pread(unsigned int fd, char *buf, u32 count, u32 pos)
691 {
692 ssize_t (*sys_pread)(unsigned int, char *, size_t, loff_t) =
693 (ssize_t (*)(unsigned int, char *, size_t, loff_t))SYS(pread);
694
695 return sys_pread(fd, buf, count, (loff_t)pos);
696 }
697
698 asmlinkage int solaris_pwrite(unsigned int fd, char *buf, u32 count, u32 pos)
699 {
700 ssize_t (*sys_pwrite)(unsigned int, char *, size_t, loff_t) =
701 (ssize_t (*)(unsigned int, char *, size_t, loff_t))SYS(pwrite);
702
703 return sys_pwrite(fd, buf, count, (loff_t)pos);
704 }
705
706 /* POSIX.1 names */
707 #define _PC_LINK_MAX 1
708 #define _PC_MAX_CANON 2
709 #define _PC_MAX_INPUT 3
710 #define _PC_NAME_MAX 4
711 #define _PC_PATH_MAX 5
712 #define _PC_PIPE_BUF 6
713 #define _PC_NO_TRUNC 7
714 #define _PC_VDISABLE 8
715 #define _PC_CHOWN_RESTRICTED 9
716 /* POSIX.4 names */
717 #define _PC_ASYNC_IO 10
718 #define _PC_PRIO_IO 11
719 #define _PC_SYNC_IO 12
720 #define _PC_LAST 12
721
722 /* This is not a real and complete implementation yet, just to keep
723 * the easy Solaris binaries happy.
724 */
725 asmlinkage int solaris_fpathconf(int fd, int name)
726 {
727 int ret;
728
729 switch(name) {
730 case _PC_LINK_MAX:
731 ret = LINK_MAX;
732 break;
733 case _PC_MAX_CANON:
734 ret = MAX_CANON;
735 break;
736 case _PC_MAX_INPUT:
737 ret = MAX_INPUT;
738 break;
739 case _PC_NAME_MAX:
740 ret = NAME_MAX;
741 break;
742 case _PC_PATH_MAX:
743 ret = PATH_MAX;
744 break;
745 case _PC_PIPE_BUF:
746 ret = PIPE_BUF;
747 break;
748 case _PC_CHOWN_RESTRICTED:
749 ret = 1;
750 break;
751 case _PC_NO_TRUNC:
752 case _PC_VDISABLE:
753 ret = 0;
754 break;
755 default:
756 ret = -EINVAL;
757 break;
758 }
759 return ret;
760 }
761
762 asmlinkage int solaris_pathconf(u32 path, int name)
763 {
764 return solaris_fpathconf(0, name);
765 }
766
767 /* solaris_llseek returns long long - quite difficult */
768 asmlinkage long solaris_llseek(struct pt_regs *regs, u32 off_hi, u32 off_lo, int whence)
769 {
770 int (*sys_llseek)(unsigned int, unsigned long, unsigned long, loff_t *, unsigned int) =
771 (int (*)(unsigned int, unsigned long, unsigned long, loff_t *, unsigned int))SYS(_llseek);
772 int ret;
773 mm_segment_t old_fs = get_fs();
774 loff_t retval;
775
776 set_fs(KERNEL_DS);
777 ret = sys_llseek((unsigned int)regs->u_regs[UREG_I0], off_hi, off_lo, &retval, whence);
778 set_fs(old_fs);
779 if (ret < 0) return ret;
780 regs->u_regs[UREG_I1] = (u32)retval;
781 return (retval >> 32);
782 }
783
784 /* Have to mask out all but lower 3 bits */
785 asmlinkage int solaris_access(u32 filename, long mode)
786 {
787 int (*sys_access)(const char *, int) =
788 (int (*)(const char *, int))SYS(access);
789
790 return sys_access((const char *)A(filename), mode & 7);
791 }
792