libcfs/libcfs/darwin/darwin-fs.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  19  *
  20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  21  * CA 95054 USA or visit www.sun.com if you need additional information or
  22  * have any questions.
  23  *
  24  * GPL HEADER END
  25  */
  26 /*
  27  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Use is subject to license terms.
  29  */
  30 /*
  31  * This file is part of Lustre, http://www.lustre.org/
  32  * Lustre is a trademark of Sun Microsystems, Inc.
  33  *
  34  * libcfs/libcfs/darwin/darwin-fs.c
  35  *
  36  * Darwin porting library
  37  * Make things easy to port
  38  *
  39  * Author: Phil Schwan <phil@clusterfs.com>
  40  */
  41
  42 #include <mach/mach_types.h>
  43 #include <string.h>
  44 #include <sys/file.h>
  45 #include <sys/malloc.h>
  46 #include <sys/conf.h>
  47 #include <sys/mount.h>
  48 #include <sys/uio.h>
  49 #include <sys/filedesc.h>
  50 #include <sys/namei.h>
  51
  52 #define DEBUG_SUBSYSTEM S_LNET
  53
  54 #include <libcfs/libcfs.h>
  55
  56 /*
  57  * Kernel APIs for file system in xnu
  58  *
  59  * Public functions
  60  */
  61
  62 #ifdef __DARWIN8__
  63 #include <sys/vnode.h>
  64
  65 extern int vn_rdwr(enum uio_rw, vnode_t, caddr_t, int, off_t, enum uio_seg, int, kauth_cred_t, int *, proc_t);
  66
  67 /* vnode_size() is not exported */
  68 static errno_t
  69 vnode_size(vnode_t vp, off_t *sizep, vfs_context_t ctx)
  70 {
  71         struct vnode_attr       va;
  72         int                     error;
  73
  74         VATTR_INIT(&va);
  75         VATTR_WANTED(&va, va_data_size);
  76         error = vnode_getattr(vp, &va, ctx);
  77         if (!error)
  78                 *sizep = va.va_data_size;
  79         return(error);
  80 }
  81
  82 /*
  83  * XXX Liang:
  84  *
  85  * kern_file_*() are not safe for multi-threads now,
  86  * however, we need them only for tracefiled, so it's
  87  * not so important to implement for MT.
  88  */
  89 int
  90 kern_file_size(struct cfs_kern_file *fp, off_t *psize)
  91 {
  92         int     error;
  93         off_t   size;
  94
  95         error = vnode_size(fp->f_vp, &size, fp->f_ctxt);
  96         if (error)
  97                 return error;
  98
  99         if (psize)
 100                 *psize = size;
 101         return 0;
 102 }
 103
 104 struct cfs_kern_file *
 105 kern_file_open(const char *filename, int uflags, int mode)
 106 {
 107         struct cfs_kern_file    *fp;
 108         vnode_t                 vp;
 109         int                     error;
 110
 111         fp = (struct cfs_kern_file *)_MALLOC(sizeof(struct cfs_kern_file),
 112                                              M_TEMP, M_WAITOK);
 113         if (fp == NULL)
 114                 return ERR_PTR(-ENOMEM);
 115
 116         fp->f_flags = FFLAGS(uflags);
 117         fp->f_ctxt = vfs_context_create(NULL);
 118
 119         error = vnode_open(filename, fp->f_flags, mode, 0, &vp, fp->f_ctxt);
 120         if (error != 0) {
 121                 _FREE(fp, M_TEMP);
 122                 return ERR_PTR(-error);
 123         } else {
 124                 fp->f_vp = vp;
 125         }
 126
 127         return fp;
 128 }
 129
 130 int
 131 kern_file_close(struct cfs_kern_file *fp)
 132 {
 133         vnode_close(fp->f_vp, fp->f_flags, fp->f_ctxt);
 134         vfs_context_rele(fp->f_ctxt);
 135         _FREE(fp, M_TEMP);
 136
 137         return 0;
 138 }
 139
 140 int
 141 kern_file_read(struct cfs_kern_file *fp, void *buf, size_t nbytes, loff_t *pos)
 142 {
 143         struct proc *p = current_proc();
 144         int     resid;
 145         int     error;
 146
 147         assert(buf != NULL);
 148         assert(fp != NULL && fp->f_vp != NULL);
 149
 150         error = vn_rdwr(UIO_READ, fp->f_vp, buf, nbytes, *pos,
 151                         UIO_SYSSPACE32, 0, vfs_context_ucred(fp->f_ctxt), &resid, p);
 152         if ((error) || (nbytes == resid)) {
 153                 if (!error)
 154                         error = -EINVAL;
 155                 return error;
 156         }
 157         *pos += nbytes - resid;
 158
 159         return (int)(nbytes - resid);
 160 }
 161
 162 int
 163 kern_file_write(struct cfs_kern_file *fp, void *buf, size_t nbytes, loff_t *pos)
 164 {
 165         struct proc *p = current_proc();
 166         int     resid;
 167         int     error;
 168
 169         assert(buf != NULL);
 170         assert(fp != NULL && fp->f_vp != NULL);
 171
 172         error = vn_rdwr(UIO_WRITE, fp->f_vp, buf, nbytes, *pos,
 173                         UIO_SYSSPACE32, 0, vfs_context_ucred(fp->f_ctxt), &resid, p);
 174         if ((error) || (nbytes == resid)) {
 175                 if (!error)
 176                         error = -EINVAL;
 177                 return error;
 178         }
 179         *pos += nbytes - resid;
 180
 181         return (int)(nbytes - resid);
 182
 183 }
 184
 185 int
 186 kern_file_sync (struct cfs_kern_file *fp)
 187 {
 188         return VNOP_FSYNC(fp->f_vp, MNT_WAIT, fp->f_ctxt);
 189 }
 190
 191 #else  /* !__DARWIN8__ */
 192
 193 int
 194 kern_file_size(struct file *fp, off_t *size)
 195 {
 196         struct vnode *vp = (struct vnode *)fp->f_data;
 197         struct stat sb;
 198         int     rc;
 199
 200         rc = vn_stat(vp, &sb, current_proc());
 201         if (rc) {
 202                 *size = 0;
 203                 return rc;
 204         }
 205         *size = sb.st_size;
 206         return 0;
 207 }
 208
 209 struct file *
 210 kern_file_open(const char *filename, int flags, int mode)
 211 {
 212         struct nameidata        nd;
 213         struct file             *fp;
 214         register struct vnode   *vp;
 215         int                     rc;
 216         extern struct fileops   vnops;
 217         extern int nfiles;
 218         CFS_DECL_CONE_DATA;
 219
 220         CFS_CONE_IN;
 221         nfiles++;
 222         MALLOC_ZONE(fp, struct file *, sizeof(file_t), M_FILE, M_WAITOK|M_ZERO);
 223         bzero(fp, sizeof(*fp));
 224         fp->f_count = 1;
 225         LIST_CIRCLE(fp, f_list);
 226         NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, (char *)filename, current_proc());
 227         if ((rc = vn_open(&nd, flags, mode)) != 0){
 228                 printf("filp_open failed at (%d)\n", rc);
 229                 FREE_ZONE(fp, sizeof(*fp), M_FILE);
 230                 CFS_CONE_EX;
 231                 return ERR_PTR(rc);
 232         }
 233         vp = nd.ni_vp;
 234         fp->f_flag = flags & FMASK;
 235         fp->f_type = DTYPE_VNODE;
 236         fp->f_ops = &vnops;
 237         fp->f_data = (caddr_t)vp;
 238         fp->f_cred = current_proc()->p_ucred;
 239         /*
 240          * Hold cred to increase reference
 241          */
 242         crhold(fp->f_cred);
 243         /*
 244          * vnode is locked inside vn_open for lookup,
 245          * we should release the lock before return
 246          */
 247         VOP_UNLOCK(vp, 0, current_proc());
 248         CFS_CONE_EX;
 249
 250         return fp;
 251 }
 252
 253 static int
 254 frele_internal(struct file *fp)
 255 {
 256         if (fp->f_count == (short)0xffff)
 257                 panic("frele of lustre: stale");
 258         if (--fp->f_count < 0)
 259                 panic("frele of lustre: count < 0");
 260         return ((int)fp->f_count);
 261 }
 262
 263 int
 264 kern_file_close(struct file *fp)
 265 {
 266         struct vnode    *vp;
 267         CFS_DECL_CONE_DATA;
 268
 269         if (fp == NULL)
 270                 return 0;
 271
 272         CFS_CONE_IN;
 273         if (frele_internal(fp) > 0)
 274                 goto out;
 275         vp = (struct vnode *)fp->f_data;
 276         (void )vn_close(vp, fp->f_flag, fp->f_cred, current_proc());
 277         /*
 278          * ffree(fp);
 279          * Dont use ffree to release fp!!!!
 280          * ffree will call LIST_REMOVE(fp),
 281          * but fp is not in any list, this will
 282          * cause kernel panic
 283          */
 284         struct ucred *cred;
 285         cred = fp->f_cred;
 286         if (cred != NOCRED) {
 287                 fp->f_cred = NOCRED;
 288                 crfree(cred);
 289         }
 290         extern int nfiles;
 291         nfiles--;
 292         memset(fp, 0xff, sizeof *fp);
 293         fp->f_count = (short)0xffff;
 294         FREE_ZONE(fp, sizeof *fp, M_FILE);
 295 out:
 296         CFS_CONE_EX;
 297         return 0;
 298 }
 299
 300 extern void bwillwrite(void);
 301
 302 /*
 303  * Write buffer to filp inside kernel
 304  */
 305 int
 306 kern_file_write(struct file *fp, void *buf, size_t nbyte, loff_t *pos)
 307 {
 308         struct uio auio;
 309         struct iovec aiov;
 310         struct proc *p = current_proc();
 311         long cnt, error = 0;
 312         int flags = 0;
 313         CFS_DECL_CONE_DATA;
 314
 315         aiov.iov_base = (void *)(uintptr_t)buf;
 316         aiov.iov_len = nbyte;
 317         auio.uio_iov = &aiov;
 318         auio.uio_iovcnt = 1;
 319         if (pos != NULL) {
 320                 auio.uio_offset = *pos;
 321                 /*
 322                  * Liang: If don't set FOF_OFFSET, vn_write()
 323                  * will use fp->f_offset as the the real offset.
 324                  * Same in vn_read()
 325                  */
 326                 flags |= FOF_OFFSET;
 327         } else
 328                 auio.uio_offset = (off_t)-1;
 329         if (nbyte > INT_MAX)
 330                 return (EINVAL);
 331         auio.uio_resid = nbyte;
 332         auio.uio_rw = UIO_WRITE;
 333         auio.uio_segflg = UIO_SYSSPACE;
 334         auio.uio_procp = p;
 335
 336         cnt = nbyte;
 337         CFS_CONE_IN;
 338         if (fp->f_type == DTYPE_VNODE)
 339                 bwillwrite();   /* empty stuff now */
 340         if ((error = fo_write(fp, &auio, fp->f_cred, flags, p))) {
 341                 if (auio.uio_resid != cnt && (error == ERESTART ||\
 342                     error == EINTR || error == EWOULDBLOCK))
 343                         error = 0;
 344                 /* The socket layer handles SIGPIPE */
 345                 if (error == EPIPE && fp->f_type != DTYPE_SOCKET)
 346                         psignal(p, SIGPIPE);
 347         }
 348         CFS_CONE_EX;
 349         if (error != 0)
 350                 cnt = -error;
 351         else
 352                 cnt -= auio.uio_resid;
 353         if (pos != NULL)
 354                 *pos += cnt;
 355         return cnt;
 356 }
 357
 358 /*
 359  * Read from filp inside kernel
 360  */
 361 int
 362 kern_file_read(struct file *fp, void *buf, size_t nbyte, loff_t *pos)
 363 {
 364         struct uio auio;
 365         struct iovec aiov;
 366         struct proc *p = current_proc();
 367         long cnt, error = 0;
 368         int  flags = 0;
 369         CFS_DECL_CONE_DATA;
 370
 371         aiov.iov_base = (caddr_t)buf;
 372         aiov.iov_len = nbyte;
 373         auio.uio_iov = &aiov;
 374         auio.uio_iovcnt = 1;
 375         if (pos != NULL) {
 376                 auio.uio_offset = *pos;
 377                 flags |= FOF_OFFSET;
 378         } else
 379                 auio.uio_offset = (off_t)-1;
 380         if (nbyte > INT_MAX)
 381                 return (EINVAL);
 382         auio.uio_resid = nbyte;
 383         auio.uio_rw = UIO_READ;
 384         auio.uio_segflg = UIO_SYSSPACE;
 385         auio.uio_procp = p;
 386
 387         cnt = nbyte;
 388         CFS_CONE_IN;
 389         if ((error = fo_read(fp, &auio, fp->f_cred, flags, p)) != 0) {
 390                 if (auio.uio_resid != cnt && (error == ERESTART ||
 391                     error == EINTR || error == EWOULDBLOCK))
 392                         error = 0;
 393         }
 394         CFS_CONE_EX;
 395         if (error != 0)
 396                 cnt = -error;
 397         else
 398                 cnt -= auio.uio_resid;
 399         if (pos != NULL)
 400                 *pos += cnt;
 401
 402         return cnt;
 403 }
 404
 405 int
 406 kern_file_sync(struct file *fp)
 407 {
 408         struct vnode *vp = (struct vnode *)fp->f_data;
 409         struct proc *p = current_proc();
 410         int error = 0;
 411         CFS_DECL_CONE_DATA;
 412
 413         CFS_CONE_IN;
 414         if (fref(fp) == -1) {
 415                 CFS_CONE_EX;
 416                 return (-EBADF);
 417         }
 418         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
 419         error = VOP_FSYNC(vp, fp->f_cred, MNT_WAIT, p);
 420         VOP_UNLOCK(vp, 0, p);
 421         frele(fp);
 422         CFS_CONE_EX;
 423
 424         return error;
 425 }
 426
 427 #endif /* !__DARWIN8__ */
 428
 429 struct posix_acl *posix_acl_alloc(int count, int flags)
 430 {
 431         static struct posix_acl acl;
 432         return &acl;
 433 }