arch/sparc64/solaris/fs.c

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