1 /* $NetBSD: ufs.c,v 1.20 1998/03/01 07:15:39 ross Exp $ */
4 * Copyright (c) 2002 Networks Associates Technology, Inc.
7 * This software was developed for the FreeBSD Project by Marshall
8 * Kirk McKusick and Network Associates Laboratories, the Security
9 * Research Division of Network Associates, Inc. under DARPA/SPAWAR
10 * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS
13 * Copyright (c) 1982, 1989, 1993
14 * The Regents of the University of California. All rights reserved.
16 * This code is derived from software contributed to Berkeley by
17 * The Mach Operating System project at Carnegie-Mellon University.
19 * Redistribution and use in source and binary forms, with or without
20 * modification, are permitted provided that the following conditions
22 * 1. Redistributions of source code must retain the above copyright
23 * notice, this list of conditions and the following disclaimer.
24 * 2. Redistributions in binary form must reproduce the above copyright
25 * notice, this list of conditions and the following disclaimer in the
26 * documentation and/or other materials provided with the distribution.
27 * 3. Neither the name of the University nor the names of its contributors
28 * may be used to endorse or promote products derived from this software
29 * without specific prior written permission.
31 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
32 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
33 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
34 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
35 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
39 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
40 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
44 * Copyright (c) 1990, 1991 Carnegie Mellon University
45 * All Rights Reserved.
49 * Permission to use, copy, modify and distribute this software and its
50 * documentation is hereby granted, provided that both the copyright
51 * notice and this permission notice appear in all copies of the
52 * software, derivative works or modified versions, and any portions
53 * thereof, and that both notices appear in supporting documentation.
55 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
56 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
57 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
59 * Carnegie Mellon requests users of this software to return to
61 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
62 * School of Computer Science
63 * Carnegie Mellon University
64 * Pittsburgh PA 15213-3890
66 * any improvements or extensions that they make and grant Carnegie the
67 * rights to redistribute these changes.
70 #include <sys/cdefs.h>
71 __FBSDID("$FreeBSD$");
74 * Stand-alone file reading package.
77 #include <sys/param.h>
78 #include <sys/disklabel.h>
80 #include <ufs/ufs/dinode.h>
81 #include <ufs/ufs/dir.h>
82 #include <ufs/ffs/fs.h>
86 static int ufs_open(const char *path, struct open_file *f);
87 static int ufs_write(struct open_file *f, const void *buf, size_t size,
89 static int ufs_close(struct open_file *f);
90 static int ufs_read(struct open_file *f, void *buf, size_t size, size_t *resid);
91 static off_t ufs_seek(struct open_file *f, off_t offset, int where);
92 static int ufs_stat(struct open_file *f, struct stat *sb);
93 static int ufs_readdir(struct open_file *f, struct dirent *d);
95 struct fs_ops ufs_fsops = {
110 off_t f_seekp; /* seek pointer */
111 struct fs *f_fs; /* pointer to super-block */
113 struct ufs1_dinode di1;
114 struct ufs2_dinode di2;
115 } f_di; /* copy of on-disk inode */
116 int f_nindir[UFS_NIADDR];
117 /* number of blocks mapped by
118 indirect block at level i */
119 char *f_blk[UFS_NIADDR]; /* buffer for indirect block at
121 size_t f_blksize[UFS_NIADDR];
123 ufs2_daddr_t f_blkno[UFS_NIADDR];/* disk address of block in buffer */
124 ufs2_daddr_t f_buf_blkno; /* block number of data block */
125 char *f_buf; /* buffer for data block */
126 size_t f_buf_size; /* size of data block */
127 int f_inumber; /* inumber */
129 #define DIP(fp, field) \
130 ((fp)->f_fs->fs_magic == FS_UFS1_MAGIC ? \
131 (fp)->f_di.di1.field : (fp)->f_di.di2.field)
133 static int read_inode(ino_t, struct open_file *);
134 static int block_map(struct open_file *, ufs2_daddr_t, ufs2_daddr_t *);
135 static int buf_read_file(struct open_file *, char **, size_t *);
136 static int buf_write_file(struct open_file *, const char *, size_t *);
137 static int search_directory(char *, struct open_file *, ino_t *);
138 static int ufs_use_sa_read(void *, off_t, void **, int);
140 /* from ffs_subr.c */
141 int ffs_sbget(void *, struct fs **, off_t, char *,
142 int (*)(void *, off_t, void **, int));
144 * Request standard superblock location in ffs_sbget
146 #define STDSB -1 /* Fail if check-hash is bad */
147 #define STDSB_NOHASHFAIL -2 /* Ignore check-hash failure */
150 * Read a new inode into a file structure.
153 read_inode(inumber, f)
157 struct file *fp = (struct file *)f->f_fsdata;
158 struct fs *fs = fp->f_fs;
167 * Read inode and save it.
169 buf = malloc(fs->fs_bsize);
171 rc = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
172 fsbtodb(fs, ino_to_fsba(fs, inumber)), fs->fs_bsize,
176 if (rsize != fs->fs_bsize) {
181 if (fp->f_fs->fs_magic == FS_UFS1_MAGIC)
182 fp->f_di.di1 = ((struct ufs1_dinode *)buf)
183 [ino_to_fsbo(fs, inumber)];
185 fp->f_di.di2 = ((struct ufs2_dinode *)buf)
186 [ino_to_fsbo(fs, inumber)];
189 * Clear out the old buffers
194 for (level = 0; level < UFS_NIADDR; level++)
195 fp->f_blkno[level] = -1;
196 fp->f_buf_blkno = -1;
199 fp->f_inumber = inumber;
206 * Given an offset in a file, find the disk block number that
207 * contains that block.
210 block_map(f, file_block, disk_block_p)
212 ufs2_daddr_t file_block;
213 ufs2_daddr_t *disk_block_p; /* out */
215 struct file *fp = (struct file *)f->f_fsdata;
216 struct fs *fs = fp->f_fs;
219 ufs2_daddr_t ind_block_num;
223 * Index structure of an inode:
225 * di_db[0..UFS_NDADDR-1] hold block numbers for blocks
228 * di_ib[0] index block 0 is the single indirect block
229 * holds block numbers for blocks
230 * UFS_NDADDR .. UFS_NDADDR + NINDIR(fs)-1
232 * di_ib[1] index block 1 is the double indirect block
233 * holds block numbers for INDEX blocks for blocks
234 * UFS_NDADDR + NINDIR(fs) ..
235 * UFS_NDADDR + NINDIR(fs) + NINDIR(fs)**2 - 1
237 * di_ib[2] index block 2 is the triple indirect block
238 * holds block numbers for double-indirect
240 * UFS_NDADDR + NINDIR(fs) + NINDIR(fs)**2 ..
241 * UFS_NDADDR + NINDIR(fs) + NINDIR(fs)**2
242 * + NINDIR(fs)**3 - 1
245 if (file_block < UFS_NDADDR) {
247 *disk_block_p = DIP(fp, di_db[file_block]);
251 file_block -= UFS_NDADDR;
255 * nindir[1] = NINDIR**2
256 * nindir[2] = NINDIR**3
259 for (level = 0; level < UFS_NIADDR; level++) {
260 if (file_block < fp->f_nindir[level])
262 file_block -= fp->f_nindir[level];
264 if (level == UFS_NIADDR) {
265 /* Block number too high */
269 ind_block_num = DIP(fp, di_ib[level]);
271 for (; level >= 0; level--) {
272 if (ind_block_num == 0) {
273 *disk_block_p = 0; /* missing */
277 if (fp->f_blkno[level] != ind_block_num) {
278 if (fp->f_blk[level] == (char *)0)
280 malloc(fs->fs_bsize);
282 rc = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
283 fsbtodb(fp->f_fs, ind_block_num),
286 &fp->f_blksize[level]);
289 if (fp->f_blksize[level] != fs->fs_bsize)
291 fp->f_blkno[level] = ind_block_num;
295 idx = file_block / fp->f_nindir[level - 1];
296 file_block %= fp->f_nindir[level - 1];
300 if (fp->f_fs->fs_magic == FS_UFS1_MAGIC)
301 ind_block_num = ((ufs1_daddr_t *)fp->f_blk[level])[idx];
303 ind_block_num = ((ufs2_daddr_t *)fp->f_blk[level])[idx];
306 *disk_block_p = ind_block_num;
312 * Write a portion of a file from an internal buffer.
315 buf_write_file(f, buf_p, size_p)
318 size_t *size_p; /* out */
320 struct file *fp = (struct file *)f->f_fsdata;
321 struct fs *fs = fp->f_fs;
323 ufs_lbn_t file_block;
324 ufs2_daddr_t disk_block;
329 * Calculate the starting block address and offset.
331 off = blkoff(fs, fp->f_seekp);
332 file_block = lblkno(fs, fp->f_seekp);
333 block_size = sblksize(fs, DIP(fp, di_size), file_block);
335 rc = block_map(f, file_block, &disk_block);
340 /* Because we can't allocate space on the drive */
344 * Truncate buffer at end of file, and at the end of
347 if (*size_p > DIP(fp, di_size) - fp->f_seekp)
348 *size_p = DIP(fp, di_size) - fp->f_seekp;
349 if (*size_p > block_size - off)
350 *size_p = block_size - off;
353 * If we don't entirely occlude the block and it's not
354 * in memory already, read it in first.
356 if (((off > 0) || (*size_p + off < block_size)) &&
357 (file_block != fp->f_buf_blkno)) {
359 if (fp->f_buf == (char *)0)
360 fp->f_buf = malloc(fs->fs_bsize);
363 rc = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
364 fsbtodb(fs, disk_block),
365 block_size, fp->f_buf, &fp->f_buf_size);
369 fp->f_buf_blkno = file_block;
373 * Copy the user data into the cached block.
375 bcopy(buf_p, fp->f_buf + off, *size_p);
378 * Write the block out to storage.
382 rc = (f->f_dev->dv_strategy)(f->f_devdata, F_WRITE,
383 fsbtodb(fs, disk_block),
384 block_size, fp->f_buf, &fp->f_buf_size);
389 * Read a portion of a file into an internal buffer. Return
390 * the location in the buffer and the amount in the buffer.
393 buf_read_file(f, buf_p, size_p)
395 char **buf_p; /* out */
396 size_t *size_p; /* out */
398 struct file *fp = (struct file *)f->f_fsdata;
399 struct fs *fs = fp->f_fs;
401 ufs_lbn_t file_block;
402 ufs2_daddr_t disk_block;
406 off = blkoff(fs, fp->f_seekp);
407 file_block = lblkno(fs, fp->f_seekp);
408 block_size = sblksize(fs, DIP(fp, di_size), file_block);
410 if (file_block != fp->f_buf_blkno) {
411 if (fp->f_buf == (char *)0)
412 fp->f_buf = malloc(fs->fs_bsize);
414 rc = block_map(f, file_block, &disk_block);
418 if (disk_block == 0) {
419 bzero(fp->f_buf, block_size);
420 fp->f_buf_size = block_size;
423 rc = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
424 fsbtodb(fs, disk_block),
425 block_size, fp->f_buf, &fp->f_buf_size);
430 fp->f_buf_blkno = file_block;
434 * Return address of byte in buffer corresponding to
435 * offset, and size of remainder of buffer after that
438 *buf_p = fp->f_buf + off;
439 *size_p = block_size - off;
442 * But truncate buffer at end of file.
444 if (*size_p > DIP(fp, di_size) - fp->f_seekp)
445 *size_p = DIP(fp, di_size) - fp->f_seekp;
451 * Search a directory for a name and return its
455 search_directory(name, f, inumber_p)
458 ino_t *inumber_p; /* out */
460 struct file *fp = (struct file *)f->f_fsdata;
468 length = strlen(name);
471 while (fp->f_seekp < DIP(fp, di_size)) {
472 rc = buf_read_file(f, &buf, &buf_size);
476 dp = (struct direct *)buf;
477 edp = (struct direct *)(buf + buf_size);
479 if (dp->d_ino == (ino_t)0)
481 #if BYTE_ORDER == LITTLE_ENDIAN
482 if (fp->f_fs->fs_maxsymlinklen <= 0)
486 namlen = dp->d_namlen;
487 if (namlen == length &&
488 !strcmp(name, dp->d_name)) {
490 *inumber_p = dp->d_ino;
494 dp = (struct direct *)((char *)dp + dp->d_reclen);
496 fp->f_seekp += buf_size;
511 ino_t inumber, parent_inumber;
516 char namebuf[MAXPATHLEN+1];
520 /* allocate file system specific data structure */
521 fp = malloc(sizeof(struct file));
522 bzero(fp, sizeof(struct file));
523 f->f_fsdata = (void *)fp;
525 /* read super block */
527 if ((rc = ffs_sbget(f, &fs, STDSB_NOHASHFAIL, "stand",
528 ufs_use_sa_read)) != 0)
532 * Calculate indirect block levels.
539 for (level = 0; level < UFS_NIADDR; level++) {
541 fp->f_nindir[level] = mult;
545 inumber = UFS_ROOTINO;
546 if ((rc = read_inode(inumber, f)) != 0)
549 cp = path = strdup(upath);
557 * Remove extra separators
565 * Check that current node is a directory.
567 if ((DIP(fp, di_mode) & IFMT) != IFDIR) {
573 * Get next component of path name.
579 while ((c = *cp) != '\0' && c != '/') {
580 if (++len > UFS_MAXNAMLEN) {
590 * Look up component in current directory.
591 * Save directory inumber in case we find a
594 parent_inumber = inumber;
595 rc = search_directory(ncp, f, &inumber);
601 * Open next component.
603 if ((rc = read_inode(inumber, f)) != 0)
607 * Check for symbolic link.
609 if ((DIP(fp, di_mode) & IFMT) == IFLNK) {
610 int link_len = DIP(fp, di_size);
615 if (link_len + len > MAXPATHLEN ||
616 ++nlinks > MAXSYMLINKS) {
621 bcopy(cp, &namebuf[link_len], len + 1);
623 if (link_len < fs->fs_maxsymlinklen) {
624 if (fp->f_fs->fs_magic == FS_UFS1_MAGIC)
625 cp = (caddr_t)(fp->f_di.di1.di_db);
627 cp = (caddr_t)(fp->f_di.di2.di_db);
628 bcopy(cp, namebuf, (unsigned) link_len);
631 * Read file for symbolic link
634 ufs2_daddr_t disk_block;
635 struct fs *fs = fp->f_fs;
638 buf = malloc(fs->fs_bsize);
639 rc = block_map(f, (ufs2_daddr_t)0, &disk_block);
644 rc = (f->f_dev->dv_strategy)(f->f_devdata,
645 F_READ, fsbtodb(fs, disk_block),
646 fs->fs_bsize, buf, &buf_size);
650 bcopy((char *)buf, namebuf, (unsigned)link_len);
654 * If relative pathname, restart at parent directory.
655 * If absolute pathname, restart at root.
659 inumber = parent_inumber;
661 inumber = (ino_t)UFS_ROOTINO;
663 if ((rc = read_inode(inumber, f)) != 0)
669 * Found terminal component.
681 if (fp->f_fs != NULL) {
682 free(fp->f_fs->fs_csp);
683 free(fp->f_fs->fs_si);
692 * A read function for use by standalone-layer routines.
695 ufs_use_sa_read(void *devfd, off_t loc, void **bufp, int size)
701 f = (struct open_file *)devfd;
702 if ((*bufp = malloc(size)) == NULL)
704 error = (f->f_dev->dv_strategy)(f->f_devdata, F_READ, loc / DEV_BSIZE,
705 size, *bufp, &buf_size);
708 if (buf_size != size)
717 struct file *fp = (struct file *)f->f_fsdata;
720 f->f_fsdata = (void *)0;
721 if (fp == (struct file *)0)
724 for (level = 0; level < UFS_NIADDR; level++) {
725 if (fp->f_blk[level])
726 free(fp->f_blk[level]);
730 if (fp->f_fs != NULL) {
731 free(fp->f_fs->fs_csp);
732 free(fp->f_fs->fs_si);
740 * Copy a portion of a file into kernel memory.
741 * Cross block boundaries when necessary.
744 ufs_read(f, start, size, resid)
748 size_t *resid; /* out */
750 struct file *fp = (struct file *)f->f_fsdata;
758 if (fp->f_seekp >= DIP(fp, di_size))
761 rc = buf_read_file(f, &buf, &buf_size);
766 if (csize > buf_size)
769 bcopy(buf, addr, csize);
771 fp->f_seekp += csize;
781 * Write to a portion of an already allocated file.
782 * Cross block boundaries when necessary. Can not
786 ufs_write(f, start, size, resid)
790 size_t *resid; /* out */
792 struct file *fp = (struct file *)f->f_fsdata;
795 const char *addr = start;
798 while ((size != 0) && (csize != 0)) {
799 if (fp->f_seekp >= DIP(fp, di_size))
802 if (csize >= 512) csize = 512; /* XXX */
804 rc = buf_write_file(f, addr, &csize);
808 fp->f_seekp += csize;
818 ufs_seek(f, offset, where)
823 struct file *fp = (struct file *)f->f_fsdata;
827 fp->f_seekp = offset;
830 fp->f_seekp += offset;
833 fp->f_seekp = DIP(fp, di_size) - offset;
839 return (fp->f_seekp);
847 struct file *fp = (struct file *)f->f_fsdata;
849 /* only important stuff */
850 sb->st_mode = DIP(fp, di_mode);
851 sb->st_uid = DIP(fp, di_uid);
852 sb->st_gid = DIP(fp, di_gid);
853 sb->st_size = DIP(fp, di_size);
854 sb->st_mtime = DIP(fp, di_mtime);
856 * The items below are ufs specific!
857 * Other fs types will need their own solution
858 * if these fields are needed.
860 sb->st_ino = fp->f_inumber;
862 * We need something to differentiate devs.
863 * fs_id is unique but 64bit, we xor the two
864 * halves to squeeze it into 32bits.
866 sb->st_dev = (dev_t)(fp->f_fs->fs_id[0] ^ fp->f_fs->fs_id[1]);
872 ufs_readdir(struct open_file *f, struct dirent *d)
874 struct file *fp = (struct file *)f->f_fsdata;
881 * assume that a directory entry will not be split across blocks
884 if (fp->f_seekp >= DIP(fp, di_size))
886 error = buf_read_file(f, &buf, &buf_size);
889 dp = (struct direct *)buf;
890 fp->f_seekp += dp->d_reclen;
891 if (dp->d_ino == (ino_t)0)
893 d->d_type = dp->d_type;
894 strcpy(d->d_name, dp->d_name);