Annotation of prex/usr/server/fs/fatfs/fatfs_vnops.c, Revision 1.1
1.1 ! nbrk 1: /*
! 2: * Copyright (c) 2005-2008, Kohsuke Ohtani
! 3: * All rights reserved.
! 4: *
! 5: * Redistribution and use in source and binary forms, with or without
! 6: * modification, are permitted provided that the following conditions
! 7: * are met:
! 8: * 1. Redistributions of source code must retain the above copyright
! 9: * notice, this list of conditions and the following disclaimer.
! 10: * 2. Redistributions in binary form must reproduce the above copyright
! 11: * notice, this list of conditions and the following disclaimer in the
! 12: * documentation and/or other materials provided with the distribution.
! 13: * 3. Neither the name of the author nor the names of any co-contributors
! 14: * may be used to endorse or promote products derived from this software
! 15: * without specific prior written permission.
! 16: *
! 17: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
! 18: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 19: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 20: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
! 21: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 22: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 23: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 24: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 25: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 26: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 27: * SUCH DAMAGE.
! 28: */
! 29:
! 30: #include <prex/prex.h>
! 31:
! 32: #include <sys/vnode.h>
! 33: #include <sys/file.h>
! 34: #include <sys/mount.h>
! 35: #include <sys/dirent.h>
! 36: #include <sys/buf.h>
! 37:
! 38: #include <ctype.h>
! 39: #include <unistd.h>
! 40: #include <errno.h>
! 41: #include <string.h>
! 42: #include <stdlib.h>
! 43: #include <fcntl.h>
! 44:
! 45: #include "fatfs.h"
! 46:
! 47: /*
! 48: * Time bits: 15-11 hours (0-23), 10-5 min, 4-0 sec /2
! 49: * Date bits: 15-9 year - 1980, 8-5 month, 4-0 day
! 50: */
! 51: #define TEMP_DATE 0x3021
! 52: #define TEMP_TIME 0
! 53:
! 54: #define fatfs_open ((vnop_open_t)vop_nullop)
! 55: #define fatfs_close ((vnop_close_t)vop_nullop)
! 56: static int fatfs_read (vnode_t, file_t, void *, size_t, size_t *);
! 57: static int fatfs_write (vnode_t, file_t, void *, size_t, size_t *);
! 58: #define fatfs_seek ((vnop_seek_t)vop_nullop)
! 59: #define fatfs_ioctl ((vnop_ioctl_t)vop_einval)
! 60: #define fatfs_fsync ((vnop_fsync_t)vop_nullop)
! 61: static int fatfs_readdir(vnode_t, file_t, struct dirent *);
! 62: static int fatfs_lookup (vnode_t, char *, vnode_t);
! 63: static int fatfs_create (vnode_t, char *, mode_t);
! 64: static int fatfs_remove (vnode_t, vnode_t, char *);
! 65: static int fatfs_rename (vnode_t, vnode_t, char *, vnode_t, vnode_t, char *);
! 66: static int fatfs_mkdir (vnode_t, char *, mode_t);
! 67: static int fatfs_rmdir (vnode_t, vnode_t, char *);
! 68: static int fatfs_getattr(vnode_t, struct vattr *);
! 69: static int fatfs_setattr(vnode_t, struct vattr *);
! 70: static int fatfs_inactive(vnode_t);
! 71: static int fatfs_truncate(vnode_t);
! 72:
! 73: /*
! 74: * vnode operations
! 75: */
! 76: struct vnops fatfs_vnops = {
! 77: fatfs_open, /* open */
! 78: fatfs_close, /* close */
! 79: fatfs_read, /* read */
! 80: fatfs_write, /* write */
! 81: fatfs_seek, /* seek */
! 82: fatfs_ioctl, /* ioctl */
! 83: fatfs_fsync, /* fsync */
! 84: fatfs_readdir, /* readdir */
! 85: fatfs_lookup, /* lookup */
! 86: fatfs_create, /* create */
! 87: fatfs_remove, /* remove */
! 88: fatfs_rename, /* remame */
! 89: fatfs_mkdir, /* mkdir */
! 90: fatfs_rmdir, /* rmdir */
! 91: fatfs_getattr, /* getattr */
! 92: fatfs_setattr, /* setattr */
! 93: fatfs_inactive, /* inactive */
! 94: fatfs_truncate, /* truncate */
! 95: };
! 96:
! 97: /*
! 98: * Read one cluster to buffer.
! 99: */
! 100: static int
! 101: fat_read_cluster(struct fatfsmount *fmp, u_long cluster)
! 102: {
! 103: u_long sec;
! 104: size_t size;
! 105:
! 106: sec = cl_to_sec(fmp, cluster);
! 107: size = fmp->sec_per_cl * SEC_SIZE;
! 108: return device_read(fmp->dev, fmp->io_buf, &size, sec);
! 109: }
! 110:
! 111: /*
! 112: * Write one cluster from buffer.
! 113: */
! 114: static int
! 115: fat_write_cluster(struct fatfsmount *fmp, u_long cluster)
! 116: {
! 117: u_long sec;
! 118: size_t size;
! 119:
! 120: sec = cl_to_sec(fmp, cluster);
! 121: size = fmp->sec_per_cl * SEC_SIZE;
! 122: return device_write(fmp->dev, fmp->io_buf, &size, sec);
! 123: }
! 124:
! 125: /*
! 126: * Lookup vnode for the specified file/directory.
! 127: * The vnode data will be set properly.
! 128: */
! 129: static int
! 130: fatfs_lookup(vnode_t dvp, char *name, vnode_t vp)
! 131: {
! 132: struct fatfsmount *fmp;
! 133: struct fat_dirent *de;
! 134: struct fatfs_node *np;
! 135: int err;
! 136:
! 137: if (*name == '\0')
! 138: return ENOENT;
! 139:
! 140: fmp = vp->v_mount->m_data;
! 141: mutex_lock(&fmp->lock);
! 142:
! 143: DPRINTF(("fatfs_lookup: name=%s\n", name));
! 144:
! 145: np = vp->v_data;
! 146: err = fatfs_lookup_node(dvp, name, np);
! 147: if (err) {
! 148: DPRINTF(("fatfs_lookup: failed!! name=%s\n", name));
! 149: mutex_unlock(&fmp->lock);
! 150: return err;
! 151: }
! 152: de = &np->dirent;
! 153: vp->v_type = IS_DIR(de) ? VDIR : VREG;
! 154: fat_attr_to_mode(de->attr, &vp->v_mode);
! 155: vp->v_mode = ALLPERMS;
! 156: vp->v_size = de->size;
! 157: vp->v_blkno = de->cluster;
! 158:
! 159: DPRINTF(("fatfs_lookup: cl=%d\n", de->cluster));
! 160: mutex_unlock(&fmp->lock);
! 161: return 0;
! 162: }
! 163:
! 164: static int
! 165: fatfs_read(vnode_t vp, file_t fp, void *buf, size_t size, size_t *result)
! 166: {
! 167: struct fatfsmount *fmp;
! 168: int nr_read, nr_copy, buf_pos, err;
! 169: u_long cl, file_pos;
! 170:
! 171: DPRINTF(("fatfs_read: vp=%x\n", vp));
! 172:
! 173: *result = 0;
! 174: fmp = vp->v_mount->m_data;
! 175:
! 176: if (vp->v_type == VDIR)
! 177: return EISDIR;
! 178: if (vp->v_type != VREG)
! 179: return EINVAL;
! 180:
! 181: /* Check if current file position is already end of file. */
! 182: file_pos = fp->f_offset;
! 183: if (file_pos >= vp->v_size)
! 184: return 0;
! 185:
! 186: mutex_lock(&fmp->lock);
! 187:
! 188: /* Get the actual read size. */
! 189: if (vp->v_size - file_pos < size)
! 190: size = vp->v_size - file_pos;
! 191:
! 192: /* Seek to the cluster for the file offset */
! 193: err = fat_seek_cluster(fmp, vp->v_blkno, file_pos, &cl);
! 194: if (err)
! 195: goto out;
! 196:
! 197: /* Read and copy data */
! 198: nr_read = 0;
! 199: buf_pos = file_pos % fmp->cluster_size;
! 200: do {
! 201: if (fat_read_cluster(fmp, cl)) {
! 202: err = EIO;
! 203: goto out;
! 204: }
! 205:
! 206: nr_copy = fmp->cluster_size;
! 207: if (buf_pos > 0)
! 208: nr_copy -= buf_pos;
! 209: if (buf_pos + size < fmp->cluster_size)
! 210: nr_copy = size;
! 211: memcpy(buf, fmp->io_buf + buf_pos, nr_copy);
! 212:
! 213: file_pos += nr_copy;
! 214: nr_read += nr_copy;
! 215: size -= nr_copy;
! 216: if (size <= 0)
! 217: break;
! 218:
! 219: err = fat_next_cluster(fmp, cl, &cl);
! 220: if (err)
! 221: goto out;
! 222:
! 223: buf = (void *)((u_long)buf + nr_copy);
! 224: buf_pos = 0;
! 225: } while (!IS_EOFCL(fmp, cl));
! 226:
! 227: fp->f_offset = file_pos;
! 228: *result = nr_read;
! 229: err = 0;
! 230: out:
! 231: mutex_unlock(&fmp->lock);
! 232: return err;
! 233: }
! 234:
! 235: static int
! 236: fatfs_write(vnode_t vp, file_t fp, void *buf, size_t size, size_t *result)
! 237: {
! 238: struct fatfsmount *fmp;
! 239: struct fatfs_node *np;
! 240: struct fat_dirent *de;
! 241: int nr_copy, nr_write, buf_pos, i, cl_size, err;
! 242: u_long file_pos, end_pos;
! 243: u_long cl;
! 244:
! 245: DPRINTF(("fatfs_write: vp=%x\n", vp));
! 246:
! 247: *result = 0;
! 248: fmp = vp->v_mount->m_data;
! 249:
! 250: if (vp->v_type == VDIR)
! 251: return EISDIR;
! 252: if (vp->v_type != VREG)
! 253: return EINVAL;
! 254:
! 255: mutex_lock(&fmp->lock);
! 256:
! 257: /* Check if file position exceeds the end of file. */
! 258: end_pos = vp->v_size;
! 259: file_pos = (fp->f_flags & O_APPEND) ? end_pos : fp->f_offset;
! 260: if (file_pos + size > end_pos) {
! 261: /* Expand the file size before writing to it */
! 262: end_pos = file_pos + size;
! 263: err = fat_expand_file(fmp, vp->v_blkno, end_pos);
! 264: if (err) {
! 265: err = EIO;
! 266: goto out;
! 267: }
! 268:
! 269: /* Update directory entry */
! 270: np = vp->v_data;
! 271: de = &np->dirent;
! 272: de->size = end_pos;
! 273: err = fatfs_put_node(fmp, np);
! 274: if (err)
! 275: goto out;
! 276: vp->v_size = end_pos;
! 277: }
! 278:
! 279: /* Seek to the cluster for the file offset */
! 280: err = fat_seek_cluster(fmp, vp->v_blkno, file_pos, &cl);
! 281: if (err)
! 282: goto out;
! 283:
! 284: buf_pos = file_pos % fmp->cluster_size;
! 285: cl_size = size / fmp->cluster_size + 1;
! 286: nr_write = 0;
! 287: i = 0;
! 288: do {
! 289: /* First and last cluster must be read before write */
! 290: if (i == 0 || i == cl_size) {
! 291: if (fat_read_cluster(fmp, cl)) {
! 292: err = EIO;
! 293: goto out;
! 294: }
! 295: }
! 296: nr_copy = fmp->cluster_size;
! 297: if (buf_pos > 0)
! 298: nr_copy -= buf_pos;
! 299: if (buf_pos + size < fmp->cluster_size)
! 300: nr_copy = size;
! 301: memcpy(fmp->io_buf + buf_pos, buf, nr_copy);
! 302:
! 303: if (fat_write_cluster(fmp, cl)) {
! 304: err = EIO;
! 305: goto out;
! 306: }
! 307: file_pos += nr_copy;
! 308: nr_write += nr_copy;
! 309: size -= nr_copy;
! 310: if (size <= 0)
! 311: break;
! 312:
! 313: err = fat_next_cluster(fmp, cl, &cl);
! 314: if (err)
! 315: goto out;
! 316:
! 317: buf = (void *)((u_long)buf + nr_copy);
! 318: buf_pos = 0;
! 319: i++;
! 320: } while (!IS_EOFCL(fmp, cl));
! 321:
! 322: fp->f_offset = file_pos;
! 323:
! 324: /*
! 325: * XXX: Todo!
! 326: * de.time = ?
! 327: * de.date = ?
! 328: * if (dirent_set(fp, &de))
! 329: * return EIO;
! 330: */
! 331: *result = nr_write;
! 332: err = 0;
! 333: out:
! 334: mutex_unlock(&fmp->lock);
! 335: return err;
! 336: }
! 337:
! 338: static int
! 339: fatfs_readdir(vnode_t vp, file_t fp, struct dirent *dir)
! 340: {
! 341: struct fatfsmount *fmp;
! 342: struct fatfs_node np;
! 343: struct fat_dirent *de;
! 344: int err;
! 345:
! 346: fmp = vp->v_mount->m_data;
! 347: mutex_lock(&fmp->lock);
! 348:
! 349: err = fatfs_get_node(vp, fp->f_offset, &np);
! 350: if (err)
! 351: goto out;
! 352: de = &np.dirent;
! 353: fat_restore_name((char *)&de->name, dir->d_name);
! 354:
! 355: if (de->attr & FA_SUBDIR)
! 356: dir->d_type = DT_DIR;
! 357: else if (de->attr & FA_DEVICE)
! 358: dir->d_type = DT_BLK;
! 359: else
! 360: dir->d_type = DT_REG;
! 361:
! 362: dir->d_fileno = fp->f_offset;
! 363: dir->d_namlen = strlen(dir->d_name);
! 364:
! 365: fp->f_offset++;
! 366: err = 0;
! 367: out:
! 368: mutex_unlock(&fmp->lock);
! 369: return err;
! 370: }
! 371:
! 372: /*
! 373: * Create empty file.
! 374: */
! 375: static int
! 376: fatfs_create(vnode_t dvp, char *name, mode_t mode)
! 377: {
! 378: struct fatfsmount *fmp;
! 379: struct fatfs_node np;
! 380: struct fat_dirent *de;
! 381: u_long cl;
! 382: int err;
! 383:
! 384: DPRINTF(("fatfs_create: %s\n", name));
! 385:
! 386: if (!S_ISREG(mode))
! 387: return EINVAL;
! 388:
! 389: if (!fat_valid_name(name))
! 390: return EINVAL;
! 391:
! 392: fmp = dvp->v_mount->m_data;
! 393: mutex_lock(&fmp->lock);
! 394:
! 395: /* Allocate free cluster for new file. */
! 396: err = fat_alloc_cluster(fmp, 0, &cl);
! 397: if (err)
! 398: goto out;
! 399:
! 400: de = &np.dirent;
! 401: memset(de, 0, sizeof(struct fat_dirent));
! 402: fat_convert_name(name, (char *)de->name);
! 403: de->cluster = cl;
! 404: de->time = TEMP_TIME;
! 405: de->date = TEMP_DATE;
! 406: fat_mode_to_attr(mode, &de->attr);
! 407: err = fatfs_add_node(dvp, &np);
! 408: if (err)
! 409: goto out;
! 410: err = fat_set_cluster(fmp, cl, fmp->fat_eof);
! 411: out:
! 412: mutex_unlock(&fmp->lock);
! 413: return err;
! 414: }
! 415:
! 416: static int
! 417: fatfs_remove(vnode_t dvp, vnode_t vp, char *name)
! 418: {
! 419: struct fatfsmount *fmp;
! 420: struct fatfs_node np;
! 421: struct fat_dirent *de;
! 422: int err;
! 423:
! 424: if (*name == '\0')
! 425: return ENOENT;
! 426:
! 427: fmp = dvp->v_mount->m_data;
! 428: mutex_lock(&fmp->lock);
! 429:
! 430: err = fatfs_lookup_node(dvp, name, &np);
! 431: if (err)
! 432: goto out;
! 433: de = &np.dirent;
! 434: if (IS_DIR(de)) {
! 435: err = EISDIR;
! 436: goto out;
! 437: }
! 438: if (!IS_FILE(de)) {
! 439: err = EPERM;
! 440: goto out;
! 441: }
! 442:
! 443: /* Remove clusters */
! 444: err = fat_free_clusters(fmp, de->cluster);
! 445: if (err)
! 446: goto out;
! 447:
! 448: /* remove directory */
! 449: de->name[0] = 0xe5;
! 450: err = fatfs_put_node(fmp, &np);
! 451: out:
! 452: mutex_unlock(&fmp->lock);
! 453: return err;
! 454: }
! 455:
! 456: static int
! 457: fatfs_rename(vnode_t dvp1, vnode_t vp1, char *name1,
! 458: vnode_t dvp2, vnode_t vp2, char *name2)
! 459: {
! 460: struct fatfsmount *fmp;
! 461: struct fatfs_node np1;
! 462: struct fat_dirent *de1, *de2;
! 463: int err;
! 464:
! 465: fmp = dvp1->v_mount->m_data;
! 466: mutex_lock(&fmp->lock);
! 467:
! 468: err = fatfs_lookup_node(dvp1, name1, &np1);
! 469: if (err)
! 470: goto out;
! 471: de1 = &np1.dirent;
! 472:
! 473: if (IS_FILE(de1)) {
! 474: /* Remove destination file, first */
! 475: err = fatfs_remove(dvp2, vp1, name2);
! 476: if (err == EIO)
! 477: goto out;
! 478:
! 479: /* Change file name of directory entry */
! 480: fat_convert_name(name2, (char *)de1->name);
! 481:
! 482: /* Same directory ? */
! 483: if (dvp1 == dvp2) {
! 484: /* Change the name of existing file */
! 485: err = fatfs_put_node(fmp, &np1);
! 486: if (err)
! 487: goto out;
! 488: } else {
! 489: /* Create new directory entry */
! 490: err = fatfs_add_node(dvp2, &np1);
! 491: if (err)
! 492: goto out;
! 493:
! 494: /* Remove souce file */
! 495: err = fatfs_remove(dvp1, vp2, name1);
! 496: if (err)
! 497: goto out;
! 498: }
! 499: } else {
! 500:
! 501: /* remove destination directory */
! 502: err = fatfs_rmdir(dvp2, NULL, name2);
! 503: if (err == EIO)
! 504: goto out;
! 505:
! 506: /* Change file name of directory entry */
! 507: fat_convert_name(name2, (char *)de1->name);
! 508:
! 509: /* Same directory ? */
! 510: if (dvp1 == dvp2) {
! 511: /* Change the name of existing directory */
! 512: err = fatfs_put_node(fmp, &np1);
! 513: if (err)
! 514: goto out;
! 515: } else {
! 516: /* Create new directory entry */
! 517: err = fatfs_add_node(dvp2, &np1);
! 518: if (err)
! 519: goto out;
! 520:
! 521: /* Update "." and ".." for renamed directory */
! 522: if (fat_read_cluster(fmp, de1->cluster)) {
! 523: err = EIO;
! 524: goto out;
! 525: }
! 526:
! 527: de2 = (struct fat_dirent *)fmp->io_buf;
! 528: de2->cluster = de1->cluster;
! 529: de2->time = TEMP_TIME;
! 530: de2->date = TEMP_DATE;
! 531: de2++;
! 532: de2->cluster = dvp2->v_blkno;
! 533: de2->time = TEMP_TIME;
! 534: de2->date = TEMP_DATE;
! 535:
! 536: if (fat_write_cluster(fmp, de1->cluster)) {
! 537: err = EIO;
! 538: goto out;
! 539: }
! 540:
! 541: /* Remove souce directory */
! 542: err = fatfs_rmdir(dvp1, NULL, name1);
! 543: if (err)
! 544: goto out;
! 545: }
! 546: }
! 547: out:
! 548: mutex_unlock(&fmp->lock);
! 549: return err;
! 550: }
! 551:
! 552: static int
! 553: fatfs_mkdir(vnode_t dvp, char *name, mode_t mode)
! 554: {
! 555: struct fatfsmount *fmp;
! 556: struct fatfs_node np;
! 557: struct fat_dirent *de;
! 558: u_long cl;
! 559: int err;
! 560:
! 561: if (!S_ISDIR(mode))
! 562: return EINVAL;
! 563:
! 564: if (!fat_valid_name(name))
! 565: return ENOTDIR;
! 566:
! 567: fmp = dvp->v_mount->m_data;
! 568: mutex_lock(&fmp->lock);
! 569:
! 570: /* Allocate free cluster for directory data */
! 571: err = fat_alloc_cluster(fmp, 0, &cl);
! 572: if (err)
! 573: goto out;
! 574:
! 575: memset(&np, 0, sizeof(struct fatfs_node));
! 576: de = &np.dirent;
! 577: fat_convert_name(name, (char *)&de->name);
! 578: de->cluster = cl;
! 579: de->time = TEMP_TIME;
! 580: de->date = TEMP_DATE;
! 581: fat_mode_to_attr(mode, &de->attr);
! 582: err = fatfs_add_node(dvp, &np);
! 583: if (err)
! 584: goto out;
! 585:
! 586: /* Initialize "." and ".." for new directory */
! 587: memset(fmp->io_buf, 0, fmp->cluster_size);
! 588:
! 589: de = (struct fat_dirent *)fmp->io_buf;
! 590: memcpy(de->name, ". ", 11);
! 591: de->attr = FA_SUBDIR;
! 592: de->cluster = cl;
! 593: de->time = TEMP_TIME;
! 594: de->date = TEMP_DATE;
! 595: de++;
! 596: memcpy(de->name, ".. ", 11);
! 597: de->attr = FA_SUBDIR;
! 598: de->cluster = dvp->v_blkno;
! 599: de->time = TEMP_TIME;
! 600: de->date = TEMP_DATE;
! 601:
! 602: if (fat_write_cluster(fmp, cl)) {
! 603: err = EIO;
! 604: goto out;
! 605: }
! 606: /* Add eof */
! 607: err = fat_set_cluster(fmp, cl, fmp->fat_eof);
! 608: out:
! 609: mutex_unlock(&fmp->lock);
! 610: return err;
! 611: }
! 612:
! 613: /*
! 614: * remove can be done only with empty directory
! 615: */
! 616: static int
! 617: fatfs_rmdir(vnode_t dvp, vnode_t vp, char *name)
! 618: {
! 619: struct fatfsmount *fmp;
! 620: struct fatfs_node np;
! 621: struct fat_dirent *de;
! 622: int err;
! 623:
! 624: if (*name == '\0')
! 625: return ENOENT;
! 626:
! 627: fmp = dvp->v_mount->m_data;
! 628: mutex_lock(&fmp->lock);
! 629:
! 630: err = fatfs_lookup_node(dvp, name, &np);
! 631: if (err)
! 632: goto out;
! 633:
! 634: de = &np.dirent;
! 635: if (!IS_DIR(de)) {
! 636: err = ENOTDIR;
! 637: goto out;
! 638: }
! 639:
! 640: /* Remove clusters */
! 641: err = fat_free_clusters(fmp, de->cluster);
! 642: if (err)
! 643: goto out;
! 644:
! 645: /* remove directory */
! 646: de->name[0] = 0xe5;
! 647:
! 648: err = fatfs_put_node(fmp, &np);
! 649: out:
! 650: mutex_unlock(&fmp->lock);
! 651: return err;
! 652: }
! 653:
! 654: static int
! 655: fatfs_getattr(vnode_t vp, struct vattr *vap)
! 656: {
! 657: /* XXX */
! 658: return 0;
! 659: }
! 660:
! 661: static int
! 662: fatfs_setattr(vnode_t vp, struct vattr *vap)
! 663: {
! 664: /* XXX */
! 665: return 0;
! 666: }
! 667:
! 668:
! 669: static int
! 670: fatfs_inactive(vnode_t vp)
! 671: {
! 672:
! 673: free(vp->v_data);
! 674: return 0;
! 675: }
! 676:
! 677: static int
! 678: fatfs_truncate(vnode_t vp)
! 679: {
! 680: struct fatfsmount *fmp;
! 681: struct fatfs_node *np;
! 682: struct fat_dirent *de;
! 683: int err;
! 684:
! 685: fmp = vp->v_mount->m_data;
! 686: mutex_lock(&fmp->lock);
! 687:
! 688: np = vp->v_data;
! 689: de = &np->dirent;
! 690:
! 691: /* Remove clusters */
! 692: err = fat_free_clusters(fmp, de->cluster);
! 693: if (err)
! 694: goto out;
! 695:
! 696: de->size = 0;
! 697:
! 698: err = fatfs_put_node(fmp, np);
! 699: if (err)
! 700: goto out;
! 701:
! 702: vp->v_size = 0;
! 703: out:
! 704: mutex_unlock(&fmp->lock);
! 705: return err;
! 706: }
! 707:
! 708: int
! 709: fatfs_init(void)
! 710: {
! 711: return 0;
! 712: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to fatfs_vnops.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex / usr / server / fs / fatfs