src/afs/LINUX24/osi_file.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <afsconfig.h>
  11 #include "afs/param.h"
  12
  13
  14 #ifdef AFS_LINUX24_ENV
  15 #include "h/module.h" /* early to avoid printf->printk mapping */
  16 #endif
  17 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  18 #include "afsincludes.h"        /* Afs-based standard headers */
  19 #include "afs/afs_stats.h"      /* afs statistics */
  20 #include "h/smp_lock.h"
  21 #if defined(AFS_LINUX26_ENV)
  22 #include "h/namei.h"
  23 #endif
  24 #if defined(LINUX_USE_FH)
  25 #include "h/exportfs.h"
  26 int cache_fh_type = -1;
  27 int cache_fh_len = -1;
  28 #endif
  29
  30 afs_lock_t afs_xosi;            /* lock is for tvattr */
  31 extern struct osi_dev cacheDev;
  32 #if defined(AFS_LINUX24_ENV)
  33 extern struct vfsmount *afs_cacheMnt;
  34 #endif
  35 extern struct super_block *afs_cacheSBp;
  36
  37 #if defined(AFS_LINUX26_ENV)
  38 struct file *
  39 afs_linux_raw_open(afs_dcache_id_t *ainode)
  40 {
  41     struct inode *tip = NULL;
  42     struct dentry *dp = NULL;
  43     struct file* filp;
  44
  45 #if !defined(LINUX_USE_FH)
  46     tip = iget(afs_cacheSBp, ainode->ufs);
  47     if (!tip)
  48         osi_Panic("Can't get inode %d\n", (int) ainode->ufs);
  49
  50     dp = d_alloc_anon(tip);
  51 #else
  52     dp = afs_cacheSBp->s_export_op->fh_to_dentry(afs_cacheSBp, &ainode->ufs.fh,
  53                                                  cache_fh_len, cache_fh_type);
  54     if (!dp)
  55            osi_Panic("Can't get dentry\n");
  56     tip = dp->d_inode;
  57 #endif
  58
  59 #if defined(S_NOATIME)
  60     tip->i_flags |= S_NOATIME; /* Disable updating access times. */
  61 #else
  62     tip->i_flags |= MS_NOATIME; /* Disable updating access times. */
  63 #endif
  64
  65 #if defined(STRUCT_TASK_HAS_CRED)
  66     filp = dentry_open(dp, mntget(afs_cacheMnt), O_RDWR, current_cred());
  67 #else
  68     filp = dentry_open(dp, mntget(afs_cacheMnt), O_RDWR);
  69 #endif
  70     if (IS_ERR(filp))
  71 #if defined(LINUX_USE_FH)
  72         osi_Panic("Can't open file\n");
  73 #else
  74         osi_Panic("Can't open inode %d\n", (int) ainode->ufs);
  75 #endif
  76     return filp;
  77 }
  78
  79 void *
  80 osi_UFSOpen(afs_dcache_id_t *ainode)
  81 {
  82     struct osi_file *afile = NULL;
  83     extern int cacheDiskType;
  84     struct file *filp = NULL;
  85     AFS_STATCNT(osi_UFSOpen);
  86     if (cacheDiskType != AFS_FCACHE_TYPE_UFS) {
  87         osi_Panic("UFSOpen called for non-UFS cache\n");
  88     }
  89     if (!afs_osicred_initialized) {
  90         /* valid for alpha_osf, SunOS, Ultrix */
  91         memset(&afs_osi_cred, 0, sizeof(afs_ucred_t));
  92         crhold(&afs_osi_cred);  /* don't let it evaporate, since it is static */
  93         afs_osicred_initialized = 1;
  94     }
  95     afile = (struct osi_file *)osi_AllocLargeSpace(sizeof(struct osi_file));
  96     AFS_GUNLOCK();
  97     if (!afile) {
  98         osi_Panic("osi_UFSOpen: Failed to allocate %d bytes for osi_file.\n",
  99                   (int)sizeof(struct osi_file));
 100     }
 101     memset(afile, 0, sizeof(struct osi_file));
 102
 103     afile->filp = afs_linux_raw_open(ainode);
 104     afile->size = i_size_read(FILE_INODE(afile->filp));
 105     AFS_GLOCK();
 106     afile->offset = 0;
 107     afile->proc = (int (*)())0;
 108     return (void *)afile;
 109 }
 110 #else
 111 void *
 112 osi_UFSOpen(afs_dcache_id_t *ainode)
 113 {
 114     register struct osi_file *afile = NULL;
 115     extern int cacheDiskType;
 116     afs_int32 code = 0;
 117     struct inode *tip = NULL;
 118     struct file *filp = NULL;
 119     AFS_STATCNT(osi_UFSOpen);
 120     if (cacheDiskType != AFS_FCACHE_TYPE_UFS) {
 121         osi_Panic("UFSOpen called for non-UFS cache\n");
 122     }
 123     if (!afs_osicred_initialized) {
 124         /* valid for alpha_osf, SunOS, Ultrix */
 125         memset(&afs_osi_cred, 0, sizeof(afs_ucred_t));
 126         crhold(&afs_osi_cred);  /* don't let it evaporate, since it is static */
 127         afs_osicred_initialized = 1;
 128     }
 129     afile = (struct osi_file *)osi_AllocLargeSpace(sizeof(struct osi_file));
 130     AFS_GUNLOCK();
 131     if (!afile) {
 132         osi_Panic("osi_UFSOpen: Failed to allocate %d bytes for osi_file.\n",
 133                   sizeof(struct osi_file));
 134     }
 135     memset(afile, 0, sizeof(struct osi_file));
 136     filp = &afile->file;
 137     filp->f_dentry = &afile->dentry;
 138     tip = iget(afs_cacheSBp, ainode->ufs);
 139     if (!tip)
 140         osi_Panic("Can't get inode %d\n", ainode->ufs);
 141     FILE_INODE(filp) = tip;
 142     tip->i_flags |= MS_NOATIME; /* Disable updating access times. */
 143     filp->f_flags = O_RDWR;
 144 #if defined(AFS_LINUX24_ENV)
 145     filp->f_mode = FMODE_READ|FMODE_WRITE;
 146     filp->f_op = fops_get(tip->i_fop);
 147 #else
 148     filp->f_op = tip->i_op->default_file_ops;
 149 #endif
 150     if (filp->f_op && filp->f_op->open)
 151         code = filp->f_op->open(tip, filp);
 152     if (code)
 153         osi_Panic("Can't open inode %d\n", ainode->ufs);
 154     afile->size = i_size_read(tip);
 155     AFS_GLOCK();
 156     afile->offset = 0;
 157     afile->proc = (int (*)())0;
 158     return (void *)afile;
 159 }
 160 #endif
 161
 162 #if defined(LINUX_USE_FH)
 163 /*
 164  * Given a dentry, return the file handle as encoded by the filesystem.
 165  * We can't assume anything about the length (words, not bytes).
 166  * The cache has to live on a single filesystem with uniform file
 167  * handles, otherwise we panic.
 168  */
 169 void osi_get_fh(struct dentry *dp, afs_ufs_dcache_id_t *ainode) {
 170     int max_len;
 171     int type;
 172
 173     if (cache_fh_len > 0)
 174         max_len = cache_fh_len;
 175     else
 176         max_len = MAX_FH_LEN;
 177     if (dp->d_sb->s_export_op->encode_fh) {
 178         type = dp->d_sb->s_export_op->encode_fh(dp, &ainode->raw[0], &max_len, 0);
 179         if (type == 255) {
 180            osi_Panic("File handle encoding failed\n");
 181         }
 182         if (cache_fh_type < 0)
 183             cache_fh_type = type;
 184         if (cache_fh_len < 0) {
 185             cache_fh_len = max_len;
 186         }
 187         if (type != cache_fh_type || max_len != cache_fh_len) {
 188            osi_Panic("Inconsistent file handles within cache\n");
 189         }
 190     } else {
 191          /* If fs doesn't provide an encode_fh method, assume the default INO32 type */
 192         if (cache_fh_type < 0)
 193             cache_fh_type = FILEID_INO32_GEN;
 194         if (cache_fh_len < 0)
 195             cache_fh_len = sizeof(struct fid)/4;
 196         ainode->fh.i32.ino = dp->d_inode->i_ino;
 197         ainode->fh.i32.gen = dp->d_inode->i_generation;
 198     }
 199 }
 200 #else
 201 void osi_get_fh(struct dentry *dp, afs_ufs_dcache_id_t *ainode) {
 202     *ainode = dp->d_inode->i_ino;
 203 }
 204 #endif
 205
 206 int
 207 afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
 208 {
 209     register afs_int32 code;
 210     AFS_STATCNT(osi_Stat);
 211     ObtainWriteLock(&afs_xosi, 320);
 212     astat->size = i_size_read(OSIFILE_INODE(afile));
 213 #if defined(AFS_LINUX26_ENV)
 214     astat->mtime = OSIFILE_INODE(afile)->i_mtime.tv_sec;
 215     astat->atime = OSIFILE_INODE(afile)->i_atime.tv_sec;
 216 #else
 217     astat->mtime = OSIFILE_INODE(afile)->i_mtime;
 218     astat->atime = OSIFILE_INODE(afile)->i_atime;
 219 #endif
 220     code = 0;
 221     ReleaseWriteLock(&afs_xosi);
 222     return code;
 223 }
 224
 225 #ifdef AFS_LINUX26_ENV
 226 int
 227 osi_UFSClose(register struct osi_file *afile)
 228 {
 229     AFS_STATCNT(osi_Close);
 230     if (afile) {
 231         if (OSIFILE_INODE(afile)) {
 232             filp_close(afile->filp, NULL);
 233         }
 234     }
 235
 236     osi_FreeLargeSpace(afile);
 237     return 0;
 238 }
 239 #else
 240 int
 241 osi_UFSClose(register struct osi_file *afile)
 242 {
 243     AFS_STATCNT(osi_Close);
 244     if (afile) {
 245         if (FILE_INODE(&afile->file)) {
 246             struct file *filp = &afile->file;
 247             if (filp->f_op && filp->f_op->release)
 248                 filp->f_op->release(FILE_INODE(filp), filp);
 249             iput(FILE_INODE(filp));
 250         }
 251     }
 252
 253     osi_FreeLargeSpace(afile);
 254     return 0;
 255 }
 256 #endif
 257
 258 int
 259 osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize)
 260 {
 261     register afs_int32 code;
 262     struct osi_stat tstat;
 263     struct iattr newattrs;
 264     struct inode *inode = OSIFILE_INODE(afile);
 265     AFS_STATCNT(osi_Truncate);
 266
 267     /* This routine only shrinks files, and most systems
 268      * have very slow truncates, even when the file is already
 269      * small enough.  Check now and save some time.
 270      */
 271     code = afs_osi_Stat(afile, &tstat);
 272     if (code || tstat.size <= asize)
 273         return code;
 274     ObtainWriteLock(&afs_xosi, 321);
 275     AFS_GUNLOCK();
 276 #ifdef STRUCT_INODE_HAS_I_ALLOC_SEM
 277     down_write(&inode->i_alloc_sem);
 278 #endif
 279 #ifdef STRUCT_INODE_HAS_I_MUTEX
 280     mutex_lock(&inode->i_mutex);
 281 #else
 282     down(&inode->i_sem);
 283 #endif
 284     newattrs.ia_size = asize;
 285     newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
 286 #if defined(AFS_LINUX24_ENV)
 287     newattrs.ia_ctime = CURRENT_TIME;
 288
 289     /* avoid notify_change() since it wants to update dentry->d_parent */
 290     lock_kernel();
 291     code = inode_change_ok(inode, &newattrs);
 292     if (!code) {
 293 #ifdef INODE_SETATTR_NOT_VOID
 294 #if defined(AFS_LINUX26_ENV)
 295         if (inode->i_op && inode->i_op->setattr)
 296             code = inode->i_op->setattr(afile->filp->f_dentry, &newattrs);
 297         else
 298 #endif
 299             code = inode_setattr(inode, &newattrs);
 300 #else
 301         inode_setattr(inode, &newattrs);
 302 #endif
 303     }
 304     unlock_kernel();
 305     if (!code)
 306         truncate_inode_pages(&inode->i_data, asize);
 307 #else
 308     i_size_write(inode, asize);
 309     if (inode->i_sb->s_op && inode->i_sb->s_op->notify_change) {
 310         code = inode->i_sb->s_op->notify_change(&afile->dentry, &newattrs);
 311     }
 312     if (!code) {
 313         truncate_inode_pages(inode, asize);
 314         if (inode->i_op && inode->i_op->truncate)
 315             inode->i_op->truncate(inode);
 316     }
 317 #endif
 318     code = -code;
 319 #ifdef STRUCT_INODE_HAS_I_MUTEX
 320     mutex_unlock(&inode->i_mutex);
 321 #else
 322     up(&inode->i_sem);
 323 #endif
 324 #ifdef STRUCT_INODE_HAS_I_ALLOC_SEM
 325     up_write(&inode->i_alloc_sem);
 326 #endif
 327     AFS_GLOCK();
 328     ReleaseWriteLock(&afs_xosi);
 329     return code;
 330 }
 331
 332
 333 /* Generic read interface */
 334 int
 335 afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
 336              afs_int32 asize)
 337 {
 338     struct uio auio;
 339     struct iovec iov;
 340     afs_int32 code;
 341
 342     AFS_STATCNT(osi_Read);
 343
 344     /*
 345      * If the osi_file passed in is NULL, panic only if AFS is not shutting
 346      * down. No point in crashing when we are already shutting down
 347      */
 348     if (!afile) {
 349         if (!afs_shuttingdown)
 350             osi_Panic("osi_Read called with null param");
 351         else
 352             return EIO;
 353     }
 354
 355     if (offset != -1)
 356         afile->offset = offset;
 357     setup_uio(&auio, &iov, aptr, afile->offset, asize, UIO_READ, AFS_UIOSYS);
 358     AFS_GUNLOCK();
 359     code = osi_rdwr(afile, &auio, UIO_READ);
 360     AFS_GLOCK();
 361     if (code == 0) {
 362         code = asize - auio.uio_resid;
 363         afile->offset += code;
 364     } else {
 365         afs_Trace2(afs_iclSetp, CM_TRACE_READFAILED, ICL_TYPE_INT32, auio.uio_resid,
 366                    ICL_TYPE_INT32, code);
 367         code = -1;
 368     }
 369     return code;
 370 }
 371
 372 /* Generic write interface */
 373 int
 374 afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
 375               afs_int32 asize)
 376 {
 377     struct uio auio;
 378     struct iovec iov;
 379     afs_int32 code;
 380
 381     AFS_STATCNT(osi_Write);
 382
 383     if (!afile) {
 384         if (!afs_shuttingdown)
 385             osi_Panic("afs_osi_Write called with null param");
 386         else
 387             return EIO;
 388     }
 389
 390     if (offset != -1)
 391         afile->offset = offset;
 392     setup_uio(&auio, &iov, aptr, afile->offset, asize, UIO_WRITE, AFS_UIOSYS);
 393     AFS_GUNLOCK();
 394     code = osi_rdwr(afile, &auio, UIO_WRITE);
 395     AFS_GLOCK();
 396     if (code == 0) {
 397         code = asize - auio.uio_resid;
 398         afile->offset += code;
 399     } else {
 400         if (code == ENOSPC)
 401             afs_warnuser
 402                 ("\n\n\n*** Cache partition is FULL - Decrease cachesize!!! ***\n\n");
 403         code = -1;
 404     }
 405
 406     if (afile->proc)
 407         (*afile->proc)(afile, code);
 408
 409     return code;
 410 }
 411
 412
 413 /*  This work should be handled by physstrat in ca/machdep.c.
 414     This routine written from the RT NFS port strategy routine.
 415     It has been generalized a bit, but should still be pretty clear. */
 416 int
 417 afs_osi_MapStrategy(int (*aproc) (struct buf * bp), register struct buf *bp)
 418 {
 419     afs_int32 returnCode;
 420
 421     AFS_STATCNT(osi_MapStrategy);
 422     returnCode = (*aproc) (bp);
 423
 424     return returnCode;
 425 }
 426
 427 void
 428 shutdown_osifile(void)
 429 {
 430     AFS_STATCNT(shutdown_osifile);
 431     if (afs_cold_shutdown) {
 432         afs_osicred_initialized = 0;
 433     }
 434 }
 435
 436 /* Intialize cache device info and fragment size for disk cache partition. */
 437 int
 438 osi_InitCacheInfo(char *aname)
 439 {
 440     int code;
 441     extern afs_dcache_id_t cacheInode;
 442     struct dentry *dp;
 443     extern struct osi_dev cacheDev;
 444     extern afs_int32 afs_fsfragsize;
 445     extern struct super_block *afs_cacheSBp;
 446     extern struct vfsmount *afs_cacheMnt;
 447     code = osi_lookupname_internal(aname, 1, &afs_cacheMnt, &dp);
 448     if (code)
 449         return ENOENT;
 450
 451     osi_get_fh(dp, &cacheInode.ufs);
 452     cacheDev.dev = dp->d_inode->i_sb->s_dev;
 453     afs_fsfragsize = dp->d_inode->i_sb->s_blocksize - 1;
 454     afs_cacheSBp = dp->d_inode->i_sb;
 455
 456     dput(dp);
 457
 458     return 0;
 459 }
 460
 461
 462 #define FOP_READ(F, B, C) (F)->f_op->read(F, B, (size_t)(C), &(F)->f_pos)
 463 #define FOP_WRITE(F, B, C) (F)->f_op->write(F, B, (size_t)(C), &(F)->f_pos)
 464
 465 /* osi_rdwr
 466  * seek, then read or write to an open inode. addrp points to data in
 467  * kernel space.
 468  */
 469 int
 470 osi_rdwr(struct osi_file *osifile, uio_t * uiop, int rw)
 471 {
 472 #ifdef AFS_LINUX26_ENV
 473     struct file *filp = osifile->filp;
 474 #else
 475     struct file *filp = &osifile->file;
 476 #endif
 477     KERNEL_SPACE_DECL;
 478     int code = 0;
 479     struct iovec *iov;
 480     afs_size_t count;
 481     unsigned long savelim;
 482
 483     savelim = current->TASK_STRUCT_RLIM[RLIMIT_FSIZE].rlim_cur;
 484     current->TASK_STRUCT_RLIM[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY;
 485
 486     if (uiop->uio_seg == AFS_UIOSYS)
 487         TO_USER_SPACE();
 488
 489     /* seek to the desired position. Return -1 on error. */
 490     if (filp->f_op->llseek) {
 491         if (filp->f_op->llseek(filp, (loff_t) uiop->uio_offset, 0) != uiop->uio_offset)
 492             return -1;
 493     } else
 494         filp->f_pos = uiop->uio_offset;
 495
 496     while (code == 0 && uiop->uio_resid > 0 && uiop->uio_iovcnt > 0) {
 497         iov = uiop->uio_iov;
 498         count = iov->iov_len;
 499         if (count == 0) {
 500             uiop->uio_iov++;
 501             uiop->uio_iovcnt--;
 502             continue;
 503         }
 504
 505         if (rw == UIO_READ)
 506             code = FOP_READ(filp, iov->iov_base, count);
 507         else
 508             code = FOP_WRITE(filp, iov->iov_base, count);
 509
 510         if (code < 0) {
 511             code = -code;
 512             break;
 513         } else if (code == 0) {
 514             /*
 515              * This is bad -- we can't read any more data from the
 516              * file, but we have no good way of signaling a partial
 517              * read either.
 518              */
 519             code = EIO;
 520             break;
 521         }
 522
 523         iov->iov_base += code;
 524         iov->iov_len -= code;
 525         uiop->uio_resid -= code;
 526         uiop->uio_offset += code;
 527         code = 0;
 528     }
 529
 530     if (uiop->uio_seg == AFS_UIOSYS)
 531         TO_KERNEL_SPACE();
 532
 533     current->TASK_STRUCT_RLIM[RLIMIT_FSIZE].rlim_cur = savelim;
 534
 535     return code;
 536 }
 537
 538 /* setup_uio
 539  * Setup a uio struct.
 540  */
 541 void
 542 setup_uio(uio_t * uiop, struct iovec *iovecp, const char *buf, afs_offs_t pos,
 543           int count, uio_flag_t flag, uio_seg_t seg)
 544 {
 545     iovecp->iov_base = (char *)buf;
 546     iovecp->iov_len = count;
 547     uiop->uio_iov = iovecp;
 548     uiop->uio_iovcnt = 1;
 549     uiop->uio_offset = pos;
 550     uiop->uio_seg = seg;
 551     uiop->uio_resid = count;
 552     uiop->uio_flag = flag;
 553 }
 554
 555
 556 /* uiomove
 557  * UIO_READ : dp -> uio
 558  * UIO_WRITE : uio -> dp
 559  */
 560 int
 561 uiomove(char *dp, int length, uio_flag_t rw, uio_t * uiop)
 562 {
 563     int count;
 564     struct iovec *iov;
 565     int code;
 566
 567     while (length > 0 && uiop->uio_resid > 0 && uiop->uio_iovcnt > 0) {
 568         iov = uiop->uio_iov;
 569         count = iov->iov_len;
 570
 571         if (!count) {
 572             uiop->uio_iov++;
 573             uiop->uio_iovcnt--;
 574             continue;
 575         }
 576
 577         if (count > length)
 578             count = length;
 579
 580         switch (uiop->uio_seg) {
 581         case AFS_UIOSYS:
 582             switch (rw) {
 583             case UIO_READ:
 584                 memcpy(iov->iov_base, dp, count);
 585                 break;
 586             case UIO_WRITE:
 587                 memcpy(dp, iov->iov_base, count);
 588                 break;
 589             default:
 590                 printf("uiomove: Bad rw = %d\n", rw);
 591                 return -EINVAL;
 592             }
 593             break;
 594         case AFS_UIOUSER:
 595             switch (rw) {
 596             case UIO_READ:
 597                 AFS_COPYOUT(dp, iov->iov_base, count, code);
 598                 break;
 599             case UIO_WRITE:
 600                 AFS_COPYIN(iov->iov_base, dp, count, code);
 601                 break;
 602             default:
 603                 printf("uiomove: Bad rw = %d\n", rw);
 604                 return -EINVAL;
 605             }
 606             break;
 607         default:
 608             printf("uiomove: Bad seg = %d\n", uiop->uio_seg);
 609             return -EINVAL;
 610         }
 611
 612         dp += count;
 613         length -= count;
 614         iov->iov_base += count;
 615         iov->iov_len -= count;
 616         uiop->uio_offset += count;
 617         uiop->uio_resid -= count;
 618     }
 619     return 0;
 620 }
 621