1199767f8SToomas Soome /* $NetBSD: ufs.c,v 1.20 1998/03/01 07:15:39 ross Exp $ */
2199767f8SToomas Soome
3cf837ed8SToomas Soome /*
4199767f8SToomas Soome * Copyright (c) 2002 Networks Associates Technology, Inc.
5199767f8SToomas Soome * All rights reserved.
6199767f8SToomas Soome *
7199767f8SToomas Soome * This software was developed for the FreeBSD Project by Marshall
8199767f8SToomas Soome * Kirk McKusick and Network Associates Laboratories, the Security
9199767f8SToomas Soome * Research Division of Network Associates, Inc. under DARPA/SPAWAR
10199767f8SToomas Soome * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS
11199767f8SToomas Soome * research program
12199767f8SToomas Soome *
13199767f8SToomas Soome * Copyright (c) 1982, 1989, 1993
14199767f8SToomas Soome * The Regents of the University of California. All rights reserved.
15199767f8SToomas Soome *
16199767f8SToomas Soome * This code is derived from software contributed to Berkeley by
17199767f8SToomas Soome * The Mach Operating System project at Carnegie-Mellon University.
18199767f8SToomas Soome *
19199767f8SToomas Soome * Redistribution and use in source and binary forms, with or without
20199767f8SToomas Soome * modification, are permitted provided that the following conditions
21199767f8SToomas Soome * are met:
22199767f8SToomas Soome * 1. Redistributions of source code must retain the above copyright
23199767f8SToomas Soome * notice, this list of conditions and the following disclaimer.
24199767f8SToomas Soome * 2. Redistributions in binary form must reproduce the above copyright
25199767f8SToomas Soome * notice, this list of conditions and the following disclaimer in the
26199767f8SToomas Soome * documentation and/or other materials provided with the distribution.
27199767f8SToomas Soome * 3. Neither the name of the University nor the names of its contributors
28199767f8SToomas Soome * may be used to endorse or promote products derived from this software
29199767f8SToomas Soome * without specific prior written permission.
30199767f8SToomas Soome *
31199767f8SToomas Soome * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
32199767f8SToomas Soome * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
33199767f8SToomas Soome * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
34199767f8SToomas Soome * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
35199767f8SToomas Soome * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36199767f8SToomas Soome * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37199767f8SToomas Soome * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38199767f8SToomas Soome * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
39199767f8SToomas Soome * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
40199767f8SToomas Soome * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
41199767f8SToomas Soome * SUCH DAMAGE.
420384eafeSToomas Soome *
43199767f8SToomas Soome *
44199767f8SToomas Soome * Copyright (c) 1990, 1991 Carnegie Mellon University
45199767f8SToomas Soome * All Rights Reserved.
46199767f8SToomas Soome *
47199767f8SToomas Soome * Author: David Golub
480384eafeSToomas Soome *
49199767f8SToomas Soome * Permission to use, copy, modify and distribute this software and its
50199767f8SToomas Soome * documentation is hereby granted, provided that both the copyright
51199767f8SToomas Soome * notice and this permission notice appear in all copies of the
52199767f8SToomas Soome * software, derivative works or modified versions, and any portions
53199767f8SToomas Soome * thereof, and that both notices appear in supporting documentation.
540384eafeSToomas Soome *
55199767f8SToomas Soome * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
56199767f8SToomas Soome * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
57199767f8SToomas Soome * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
580384eafeSToomas Soome *
59199767f8SToomas Soome * Carnegie Mellon requests users of this software to return to
600384eafeSToomas Soome *
61199767f8SToomas Soome * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
62199767f8SToomas Soome * School of Computer Science
63199767f8SToomas Soome * Carnegie Mellon University
64199767f8SToomas Soome * Pittsburgh PA 15213-3890
650384eafeSToomas Soome *
66199767f8SToomas Soome * any improvements or extensions that they make and grant Carnegie the
67199767f8SToomas Soome * rights to redistribute these changes.
68199767f8SToomas Soome */
69199767f8SToomas Soome
70199767f8SToomas Soome #include <sys/cdefs.h>
71199767f8SToomas Soome
72199767f8SToomas Soome /*
73199767f8SToomas Soome * Stand-alone file reading package.
74199767f8SToomas Soome */
75199767f8SToomas Soome
76199767f8SToomas Soome #include <sys/param.h>
77199767f8SToomas Soome #include <sys/disklabel.h>
78199767f8SToomas Soome #include <sys/time.h>
79199767f8SToomas Soome #include <ufs/ufs/dinode.h>
80199767f8SToomas Soome #include <ufs/ufs/dir.h>
81199767f8SToomas Soome #include <ufs/ffs/fs.h>
82199767f8SToomas Soome #include "stand.h"
83199767f8SToomas Soome #include "string.h"
84199767f8SToomas Soome
850384eafeSToomas Soome static int ufs_open(const char *, struct open_file *);
860384eafeSToomas Soome static int ufs_write(struct open_file *, const void *, size_t, size_t *);
870384eafeSToomas Soome static int ufs_close(struct open_file *);
880384eafeSToomas Soome static int ufs_read(struct open_file *, void *, size_t, size_t *);
890384eafeSToomas Soome static off_t ufs_seek(struct open_file *, off_t, int);
900384eafeSToomas Soome static int ufs_stat(struct open_file *, struct stat *);
910384eafeSToomas Soome static int ufs_readdir(struct open_file *, struct dirent *);
92199767f8SToomas Soome
93199767f8SToomas Soome struct fs_ops ufs_fsops = {
94199767f8SToomas Soome "ufs",
95199767f8SToomas Soome ufs_open,
96199767f8SToomas Soome ufs_close,
97199767f8SToomas Soome ufs_read,
98199767f8SToomas Soome ufs_write,
99199767f8SToomas Soome ufs_seek,
100199767f8SToomas Soome ufs_stat,
101199767f8SToomas Soome ufs_readdir
102199767f8SToomas Soome };
103199767f8SToomas Soome
104199767f8SToomas Soome /*
105199767f8SToomas Soome * In-core open file.
106199767f8SToomas Soome */
107199767f8SToomas Soome struct file {
108199767f8SToomas Soome off_t f_seekp; /* seek pointer */
109199767f8SToomas Soome struct fs *f_fs; /* pointer to super-block */
110199767f8SToomas Soome union dinode {
111199767f8SToomas Soome struct ufs1_dinode di1;
112199767f8SToomas Soome struct ufs2_dinode di2;
113199767f8SToomas Soome } f_di; /* copy of on-disk inode */
114199767f8SToomas Soome int f_nindir[NIADDR];
1150384eafeSToomas Soome /*
1160384eafeSToomas Soome * number of blocks mapped by
1170384eafeSToomas Soome * indirect block at level i
1180384eafeSToomas Soome */
1190384eafeSToomas Soome char *f_blk[NIADDR];
1200384eafeSToomas Soome /*
1210384eafeSToomas Soome * buffer for indirect block at
1220384eafeSToomas Soome * level i
1230384eafeSToomas Soome */
1240384eafeSToomas Soome size_t f_blksize[NIADDR]; /* size of buffer */
1250384eafeSToomas Soome ufs2_daddr_t f_blkno[NIADDR]; /* disk address of block in buffer */
126199767f8SToomas Soome ufs2_daddr_t f_buf_blkno; /* block number of data block */
127199767f8SToomas Soome char *f_buf; /* buffer for data block */
128199767f8SToomas Soome size_t f_buf_size; /* size of data block */
129199767f8SToomas Soome };
1300384eafeSToomas Soome #define DIP(fp, field) \
131199767f8SToomas Soome ((fp)->f_fs->fs_magic == FS_UFS1_MAGIC ? \
132199767f8SToomas Soome (fp)->f_di.di1.field : (fp)->f_di.di2.field)
133199767f8SToomas Soome
134199767f8SToomas Soome static int read_inode(ino_t, struct open_file *);
135199767f8SToomas Soome static int block_map(struct open_file *, ufs2_daddr_t, ufs2_daddr_t *);
136199767f8SToomas Soome static int buf_read_file(struct open_file *, char **, size_t *);
137cf837ed8SToomas Soome static int buf_write_file(struct open_file *, const char *, size_t *);
138199767f8SToomas Soome static int search_directory(char *, struct open_file *, ino_t *);
139199767f8SToomas Soome
140199767f8SToomas Soome /*
141199767f8SToomas Soome * Read a new inode into a file structure.
142199767f8SToomas Soome */
143199767f8SToomas Soome static int
read_inode(ino_t inumber,struct open_file * f)1440384eafeSToomas Soome read_inode(ino_t inumber, struct open_file *f)
145199767f8SToomas Soome {
146199767f8SToomas Soome struct file *fp = (struct file *)f->f_fsdata;
147199767f8SToomas Soome struct fs *fs = fp->f_fs;
148199767f8SToomas Soome char *buf;
149199767f8SToomas Soome size_t rsize;
150199767f8SToomas Soome int rc;
151199767f8SToomas Soome
152199767f8SToomas Soome if (fs == NULL)
1530384eafeSToomas Soome panic("fs == NULL");
154199767f8SToomas Soome
155199767f8SToomas Soome /*
156199767f8SToomas Soome * Read inode and save it.
157199767f8SToomas Soome */
158199767f8SToomas Soome buf = malloc(fs->fs_bsize);
159199767f8SToomas Soome twiddle(1);
160199767f8SToomas Soome rc = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
1610384eafeSToomas Soome fsbtodb(fs, ino_to_fsba(fs, inumber)), fs->fs_bsize,
1620384eafeSToomas Soome buf, &rsize);
163199767f8SToomas Soome if (rc)
164199767f8SToomas Soome goto out;
165199767f8SToomas Soome if (rsize != fs->fs_bsize) {
166199767f8SToomas Soome rc = EIO;
167199767f8SToomas Soome goto out;
168199767f8SToomas Soome }
169199767f8SToomas Soome
170199767f8SToomas Soome if (fp->f_fs->fs_magic == FS_UFS1_MAGIC)
171199767f8SToomas Soome fp->f_di.di1 = ((struct ufs1_dinode *)buf)
172199767f8SToomas Soome [ino_to_fsbo(fs, inumber)];
173199767f8SToomas Soome else
174199767f8SToomas Soome fp->f_di.di2 = ((struct ufs2_dinode *)buf)
175199767f8SToomas Soome [ino_to_fsbo(fs, inumber)];
176199767f8SToomas Soome
177199767f8SToomas Soome /*
178199767f8SToomas Soome * Clear out the old buffers
179199767f8SToomas Soome */
180199767f8SToomas Soome {
181199767f8SToomas Soome int level;
182199767f8SToomas Soome
183199767f8SToomas Soome for (level = 0; level < NIADDR; level++)
184199767f8SToomas Soome fp->f_blkno[level] = -1;
185199767f8SToomas Soome fp->f_buf_blkno = -1;
186199767f8SToomas Soome }
187199767f8SToomas Soome fp->f_seekp = 0;
188199767f8SToomas Soome out:
189199767f8SToomas Soome free(buf);
1900384eafeSToomas Soome return (rc);
191199767f8SToomas Soome }
192199767f8SToomas Soome
193199767f8SToomas Soome /*
194199767f8SToomas Soome * Given an offset in a file, find the disk block number that
195199767f8SToomas Soome * contains that block.
196199767f8SToomas Soome */
197199767f8SToomas Soome static int
block_map(struct open_file * f,ufs2_daddr_t file_block,ufs2_daddr_t * disk_block_p)1980384eafeSToomas Soome block_map(struct open_file *f, ufs2_daddr_t file_block,
1990384eafeSToomas Soome ufs2_daddr_t *disk_block_p)
200199767f8SToomas Soome {
201199767f8SToomas Soome struct file *fp = (struct file *)f->f_fsdata;
202199767f8SToomas Soome struct fs *fs = fp->f_fs;
203199767f8SToomas Soome int level;
204199767f8SToomas Soome int idx;
205199767f8SToomas Soome ufs2_daddr_t ind_block_num;
206199767f8SToomas Soome int rc;
207199767f8SToomas Soome
208199767f8SToomas Soome /*
209199767f8SToomas Soome * Index structure of an inode:
210199767f8SToomas Soome *
211199767f8SToomas Soome * di_db[0..NDADDR-1] hold block numbers for blocks
212199767f8SToomas Soome * 0..NDADDR-1
213199767f8SToomas Soome *
214199767f8SToomas Soome * di_ib[0] index block 0 is the single indirect block
215199767f8SToomas Soome * holds block numbers for blocks
216199767f8SToomas Soome * NDADDR .. NDADDR + NINDIR(fs)-1
217199767f8SToomas Soome *
218199767f8SToomas Soome * di_ib[1] index block 1 is the double indirect block
219199767f8SToomas Soome * holds block numbers for INDEX blocks for blocks
220199767f8SToomas Soome * NDADDR + NINDIR(fs) ..
221199767f8SToomas Soome * NDADDR + NINDIR(fs) + NINDIR(fs)**2 - 1
222199767f8SToomas Soome *
223199767f8SToomas Soome * di_ib[2] index block 2 is the triple indirect block
224199767f8SToomas Soome * holds block numbers for double-indirect
225199767f8SToomas Soome * blocks for blocks
226199767f8SToomas Soome * NDADDR + NINDIR(fs) + NINDIR(fs)**2 ..
227199767f8SToomas Soome * NDADDR + NINDIR(fs) + NINDIR(fs)**2
228199767f8SToomas Soome * + NINDIR(fs)**3 - 1
229199767f8SToomas Soome */
230199767f8SToomas Soome
231199767f8SToomas Soome if (file_block < NDADDR) {
232199767f8SToomas Soome /* Direct block. */
233199767f8SToomas Soome *disk_block_p = DIP(fp, di_db[file_block]);
234199767f8SToomas Soome return (0);
235199767f8SToomas Soome }
236199767f8SToomas Soome
237199767f8SToomas Soome file_block -= NDADDR;
238199767f8SToomas Soome
239199767f8SToomas Soome /*
240199767f8SToomas Soome * nindir[0] = NINDIR
241199767f8SToomas Soome * nindir[1] = NINDIR**2
242199767f8SToomas Soome * nindir[2] = NINDIR**3
243199767f8SToomas Soome * etc
244199767f8SToomas Soome */
245199767f8SToomas Soome for (level = 0; level < NIADDR; level++) {
246199767f8SToomas Soome if (file_block < fp->f_nindir[level])
247199767f8SToomas Soome break;
248199767f8SToomas Soome file_block -= fp->f_nindir[level];
249199767f8SToomas Soome }
250199767f8SToomas Soome if (level == NIADDR) {
251199767f8SToomas Soome /* Block number too high */
252199767f8SToomas Soome return (EFBIG);
253199767f8SToomas Soome }
254199767f8SToomas Soome
255199767f8SToomas Soome ind_block_num = DIP(fp, di_ib[level]);
256199767f8SToomas Soome
257199767f8SToomas Soome for (; level >= 0; level--) {
258199767f8SToomas Soome if (ind_block_num == 0) {
259199767f8SToomas Soome *disk_block_p = 0; /* missing */
260199767f8SToomas Soome return (0);
261199767f8SToomas Soome }
262199767f8SToomas Soome
263199767f8SToomas Soome if (fp->f_blkno[level] != ind_block_num) {
2640384eafeSToomas Soome if (fp->f_blk[level] == NULL)
265199767f8SToomas Soome fp->f_blk[level] =
2660384eafeSToomas Soome malloc(fs->fs_bsize);
267199767f8SToomas Soome twiddle(1);
268199767f8SToomas Soome rc = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
2690384eafeSToomas Soome fsbtodb(fp->f_fs, ind_block_num),
2700384eafeSToomas Soome fs->fs_bsize,
2710384eafeSToomas Soome fp->f_blk[level],
2720384eafeSToomas Soome &fp->f_blksize[level]);
273199767f8SToomas Soome if (rc)
274199767f8SToomas Soome return (rc);
275199767f8SToomas Soome if (fp->f_blksize[level] != fs->fs_bsize)
276199767f8SToomas Soome return (EIO);
277199767f8SToomas Soome fp->f_blkno[level] = ind_block_num;
278199767f8SToomas Soome }
279199767f8SToomas Soome
280199767f8SToomas Soome if (level > 0) {
281199767f8SToomas Soome idx = file_block / fp->f_nindir[level - 1];
282199767f8SToomas Soome file_block %= fp->f_nindir[level - 1];
283199767f8SToomas Soome } else
284199767f8SToomas Soome idx = file_block;
285199767f8SToomas Soome
286199767f8SToomas Soome if (fp->f_fs->fs_magic == FS_UFS1_MAGIC)
287199767f8SToomas Soome ind_block_num = ((ufs1_daddr_t *)fp->f_blk[level])[idx];
288199767f8SToomas Soome else
289199767f8SToomas Soome ind_block_num = ((ufs2_daddr_t *)fp->f_blk[level])[idx];
290199767f8SToomas Soome }
291199767f8SToomas Soome
292199767f8SToomas Soome *disk_block_p = ind_block_num;
293199767f8SToomas Soome
294199767f8SToomas Soome return (0);
295199767f8SToomas Soome }
296199767f8SToomas Soome
297199767f8SToomas Soome /*
298199767f8SToomas Soome * Write a portion of a file from an internal buffer.
299199767f8SToomas Soome */
300199767f8SToomas Soome static int
buf_write_file(struct open_file * f,const char * buf_p,size_t * size_p)3010384eafeSToomas Soome buf_write_file(struct open_file *f, const char *buf_p, size_t *size_p)
302199767f8SToomas Soome {
303199767f8SToomas Soome struct file *fp = (struct file *)f->f_fsdata;
304199767f8SToomas Soome struct fs *fs = fp->f_fs;
305199767f8SToomas Soome long off;
306199767f8SToomas Soome ufs_lbn_t file_block;
307199767f8SToomas Soome ufs2_daddr_t disk_block;
308199767f8SToomas Soome size_t block_size;
309199767f8SToomas Soome int rc;
310199767f8SToomas Soome
311199767f8SToomas Soome /*
312199767f8SToomas Soome * Calculate the starting block address and offset.
313199767f8SToomas Soome */
314199767f8SToomas Soome off = blkoff(fs, fp->f_seekp);
315199767f8SToomas Soome file_block = lblkno(fs, fp->f_seekp);
316199767f8SToomas Soome block_size = sblksize(fs, DIP(fp, di_size), file_block);
317199767f8SToomas Soome
318199767f8SToomas Soome rc = block_map(f, file_block, &disk_block);
319199767f8SToomas Soome if (rc)
320199767f8SToomas Soome return (rc);
321199767f8SToomas Soome
3220384eafeSToomas Soome if (disk_block == 0)
323199767f8SToomas Soome /* Because we can't allocate space on the drive */
324199767f8SToomas Soome return (EFBIG);
325199767f8SToomas Soome
326199767f8SToomas Soome /*
327199767f8SToomas Soome * Truncate buffer at end of file, and at the end of
328199767f8SToomas Soome * this block.
329199767f8SToomas Soome */
330199767f8SToomas Soome if (*size_p > DIP(fp, di_size) - fp->f_seekp)
331199767f8SToomas Soome *size_p = DIP(fp, di_size) - fp->f_seekp;
3320384eafeSToomas Soome if (*size_p > block_size - off)
333199767f8SToomas Soome *size_p = block_size - off;
334199767f8SToomas Soome
335199767f8SToomas Soome /*
336199767f8SToomas Soome * If we don't entirely occlude the block and it's not
337199767f8SToomas Soome * in memory already, read it in first.
338199767f8SToomas Soome */
339199767f8SToomas Soome if (((off > 0) || (*size_p + off < block_size)) &&
340199767f8SToomas Soome (file_block != fp->f_buf_blkno)) {
341199767f8SToomas Soome
342199767f8SToomas Soome if (fp->f_buf == (char *)0)
343199767f8SToomas Soome fp->f_buf = malloc(fs->fs_bsize);
344199767f8SToomas Soome
345199767f8SToomas Soome twiddle(8);
346199767f8SToomas Soome rc = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
3470384eafeSToomas Soome fsbtodb(fs, disk_block),
3480384eafeSToomas Soome block_size, fp->f_buf, &fp->f_buf_size);
349199767f8SToomas Soome if (rc)
350199767f8SToomas Soome return (rc);
351199767f8SToomas Soome
352199767f8SToomas Soome fp->f_buf_blkno = file_block;
353199767f8SToomas Soome }
354199767f8SToomas Soome
355199767f8SToomas Soome /*
356199767f8SToomas Soome * Copy the user data into the cached block.
357199767f8SToomas Soome */
358199767f8SToomas Soome bcopy(buf_p, fp->f_buf + off, *size_p);
359199767f8SToomas Soome
360199767f8SToomas Soome /*
361199767f8SToomas Soome * Write the block out to storage.
362199767f8SToomas Soome */
363199767f8SToomas Soome
364199767f8SToomas Soome twiddle(4);
365199767f8SToomas Soome rc = (f->f_dev->dv_strategy)(f->f_devdata, F_WRITE,
3660384eafeSToomas Soome fsbtodb(fs, disk_block),
3670384eafeSToomas Soome block_size, fp->f_buf, &fp->f_buf_size);
368199767f8SToomas Soome return (rc);
369199767f8SToomas Soome }
370199767f8SToomas Soome
371199767f8SToomas Soome /*
372199767f8SToomas Soome * Read a portion of a file into an internal buffer. Return
373199767f8SToomas Soome * the location in the buffer and the amount in the buffer.
374199767f8SToomas Soome */
375199767f8SToomas Soome static int
buf_read_file(struct open_file * f,char ** buf_p,size_t * size_p)3760384eafeSToomas Soome buf_read_file(struct open_file *f, char **buf_p, size_t *size_p)
377199767f8SToomas Soome {
378199767f8SToomas Soome struct file *fp = (struct file *)f->f_fsdata;
379199767f8SToomas Soome struct fs *fs = fp->f_fs;
380199767f8SToomas Soome long off;
381199767f8SToomas Soome ufs_lbn_t file_block;
382199767f8SToomas Soome ufs2_daddr_t disk_block;
383199767f8SToomas Soome size_t block_size;
384199767f8SToomas Soome int rc;
385199767f8SToomas Soome
386199767f8SToomas Soome off = blkoff(fs, fp->f_seekp);
387199767f8SToomas Soome file_block = lblkno(fs, fp->f_seekp);
388199767f8SToomas Soome block_size = sblksize(fs, DIP(fp, di_size), file_block);
389199767f8SToomas Soome
390199767f8SToomas Soome if (file_block != fp->f_buf_blkno) {
391199767f8SToomas Soome if (fp->f_buf == (char *)0)
392199767f8SToomas Soome fp->f_buf = malloc(fs->fs_bsize);
393199767f8SToomas Soome
394199767f8SToomas Soome rc = block_map(f, file_block, &disk_block);
395199767f8SToomas Soome if (rc)
396199767f8SToomas Soome return (rc);
397199767f8SToomas Soome
398199767f8SToomas Soome if (disk_block == 0) {
399199767f8SToomas Soome bzero(fp->f_buf, block_size);
400199767f8SToomas Soome fp->f_buf_size = block_size;
401199767f8SToomas Soome } else {
402199767f8SToomas Soome twiddle(4);
403199767f8SToomas Soome rc = (f->f_dev->dv_strategy)(f->f_devdata,
4040384eafeSToomas Soome F_READ, fsbtodb(fs, disk_block),
4050384eafeSToomas Soome block_size, fp->f_buf, &fp->f_buf_size);
406199767f8SToomas Soome if (rc)
407199767f8SToomas Soome return (rc);
408199767f8SToomas Soome }
409199767f8SToomas Soome
410199767f8SToomas Soome fp->f_buf_blkno = file_block;
411199767f8SToomas Soome }
412199767f8SToomas Soome
413199767f8SToomas Soome /*
414199767f8SToomas Soome * Return address of byte in buffer corresponding to
415199767f8SToomas Soome * offset, and size of remainder of buffer after that
416199767f8SToomas Soome * byte.
417199767f8SToomas Soome */
418199767f8SToomas Soome *buf_p = fp->f_buf + off;
419199767f8SToomas Soome *size_p = block_size - off;
420199767f8SToomas Soome
421199767f8SToomas Soome /*
422199767f8SToomas Soome * But truncate buffer at end of file.
423199767f8SToomas Soome */
424199767f8SToomas Soome if (*size_p > DIP(fp, di_size) - fp->f_seekp)
425199767f8SToomas Soome *size_p = DIP(fp, di_size) - fp->f_seekp;
426199767f8SToomas Soome
427199767f8SToomas Soome return (0);
428199767f8SToomas Soome }
429199767f8SToomas Soome
430199767f8SToomas Soome /*
431199767f8SToomas Soome * Search a directory for a name and return its
432199767f8SToomas Soome * i_number.
433199767f8SToomas Soome */
434199767f8SToomas Soome static int
search_directory(char * name,struct open_file * f,ino_t * inumber_p)4350384eafeSToomas Soome search_directory(char *name, struct open_file *f, ino_t *inumber_p)
436199767f8SToomas Soome {
437199767f8SToomas Soome struct file *fp = (struct file *)f->f_fsdata;
438199767f8SToomas Soome struct direct *dp;
439199767f8SToomas Soome struct direct *edp;
440199767f8SToomas Soome char *buf;
441199767f8SToomas Soome size_t buf_size;
442199767f8SToomas Soome int namlen, length;
443199767f8SToomas Soome int rc;
444199767f8SToomas Soome
445199767f8SToomas Soome length = strlen(name);
446199767f8SToomas Soome
447199767f8SToomas Soome fp->f_seekp = 0;
448199767f8SToomas Soome while (fp->f_seekp < DIP(fp, di_size)) {
449199767f8SToomas Soome rc = buf_read_file(f, &buf, &buf_size);
450199767f8SToomas Soome if (rc)
451199767f8SToomas Soome return (rc);
452199767f8SToomas Soome
453199767f8SToomas Soome dp = (struct direct *)buf;
454199767f8SToomas Soome edp = (struct direct *)(buf + buf_size);
455199767f8SToomas Soome while (dp < edp) {
456199767f8SToomas Soome if (dp->d_ino == (ino_t)0)
457199767f8SToomas Soome goto next;
458199767f8SToomas Soome namlen = dp->d_namlen;
459199767f8SToomas Soome if (namlen == length &&
4600384eafeSToomas Soome strcmp(name, dp->d_name) == 0) {
461199767f8SToomas Soome /* found entry */
462199767f8SToomas Soome *inumber_p = dp->d_ino;
463199767f8SToomas Soome return (0);
464199767f8SToomas Soome }
465199767f8SToomas Soome next:
466199767f8SToomas Soome dp = (struct direct *)((char *)dp + dp->d_reclen);
467199767f8SToomas Soome }
468199767f8SToomas Soome fp->f_seekp += buf_size;
469199767f8SToomas Soome }
470199767f8SToomas Soome return (ENOENT);
471199767f8SToomas Soome }
472199767f8SToomas Soome
473199767f8SToomas Soome static int sblock_try[] = SBLOCKSEARCH;
474199767f8SToomas Soome
475199767f8SToomas Soome /*
476199767f8SToomas Soome * Open a file.
477199767f8SToomas Soome */
478199767f8SToomas Soome static int
ufs_open(const char * upath,struct open_file * f)4790384eafeSToomas Soome ufs_open(const char *upath, struct open_file *f)
480199767f8SToomas Soome {
481199767f8SToomas Soome char *cp, *ncp;
482199767f8SToomas Soome int c;
483199767f8SToomas Soome ino_t inumber, parent_inumber;
484199767f8SToomas Soome struct file *fp;
485199767f8SToomas Soome struct fs *fs;
486199767f8SToomas Soome int i, rc;
487199767f8SToomas Soome size_t buf_size;
488199767f8SToomas Soome int nlinks = 0;
489199767f8SToomas Soome char namebuf[MAXPATHLEN+1];
490199767f8SToomas Soome char *buf = NULL;
491199767f8SToomas Soome char *path = NULL;
492199767f8SToomas Soome
493199767f8SToomas Soome /* allocate file system specific data structure */
4940384eafeSToomas Soome fp = malloc(sizeof (struct file));
4950384eafeSToomas Soome bzero(fp, sizeof (struct file));
496199767f8SToomas Soome f->f_fsdata = (void *)fp;
497199767f8SToomas Soome
498199767f8SToomas Soome /* allocate space and read super block */
499199767f8SToomas Soome fs = malloc(SBLOCKSIZE);
500199767f8SToomas Soome fp->f_fs = fs;
501199767f8SToomas Soome twiddle(1);
502199767f8SToomas Soome /*
503199767f8SToomas Soome * Try reading the superblock in each of its possible locations.
504199767f8SToomas Soome */
505199767f8SToomas Soome for (i = 0; sblock_try[i] != -1; i++) {
506199767f8SToomas Soome rc = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
50738dea910SToomas Soome sblock_try[i] / DEV_BSIZE, SBLOCKSIZE,
508199767f8SToomas Soome (char *)fs, &buf_size);
509199767f8SToomas Soome if (rc)
510199767f8SToomas Soome goto out;
511199767f8SToomas Soome if ((fs->fs_magic == FS_UFS1_MAGIC ||
5120384eafeSToomas Soome (fs->fs_magic == FS_UFS2_MAGIC &&
5130384eafeSToomas Soome fs->fs_sblockloc == sblock_try[i])) &&
514199767f8SToomas Soome buf_size == SBLOCKSIZE &&
515199767f8SToomas Soome fs->fs_bsize <= MAXBSIZE &&
5160384eafeSToomas Soome fs->fs_bsize >= sizeof (struct fs))
517199767f8SToomas Soome break;
518199767f8SToomas Soome }
519199767f8SToomas Soome if (sblock_try[i] == -1) {
520199767f8SToomas Soome rc = EINVAL;
521199767f8SToomas Soome goto out;
522199767f8SToomas Soome }
523199767f8SToomas Soome /*
524199767f8SToomas Soome * Calculate indirect block levels.
525199767f8SToomas Soome */
526199767f8SToomas Soome {
527199767f8SToomas Soome ufs2_daddr_t mult;
528199767f8SToomas Soome int level;
529199767f8SToomas Soome
530199767f8SToomas Soome mult = 1;
531199767f8SToomas Soome for (level = 0; level < NIADDR; level++) {
532199767f8SToomas Soome mult *= NINDIR(fs);
533199767f8SToomas Soome fp->f_nindir[level] = mult;
534199767f8SToomas Soome }
535199767f8SToomas Soome }
536199767f8SToomas Soome
537199767f8SToomas Soome inumber = ROOTINO;
538199767f8SToomas Soome if ((rc = read_inode(inumber, f)) != 0)
539199767f8SToomas Soome goto out;
540199767f8SToomas Soome
541199767f8SToomas Soome cp = path = strdup(upath);
542199767f8SToomas Soome if (path == NULL) {
5430384eafeSToomas Soome rc = ENOMEM;
5440384eafeSToomas Soome goto out;
545199767f8SToomas Soome }
546199767f8SToomas Soome while (*cp) {
547199767f8SToomas Soome
548199767f8SToomas Soome /*
549199767f8SToomas Soome * Remove extra separators
550199767f8SToomas Soome */
551199767f8SToomas Soome while (*cp == '/')
552199767f8SToomas Soome cp++;
553199767f8SToomas Soome if (*cp == '\0')
554199767f8SToomas Soome break;
555199767f8SToomas Soome
556199767f8SToomas Soome /*
557199767f8SToomas Soome * Check that current node is a directory.
558199767f8SToomas Soome */
559199767f8SToomas Soome if ((DIP(fp, di_mode) & IFMT) != IFDIR) {
560199767f8SToomas Soome rc = ENOTDIR;
561199767f8SToomas Soome goto out;
562199767f8SToomas Soome }
563199767f8SToomas Soome
564199767f8SToomas Soome /*
565199767f8SToomas Soome * Get next component of path name.
566199767f8SToomas Soome */
567199767f8SToomas Soome {
568199767f8SToomas Soome int len = 0;
569199767f8SToomas Soome
570199767f8SToomas Soome ncp = cp;
571199767f8SToomas Soome while ((c = *cp) != '\0' && c != '/') {
5728130c4e1SToomas Soome if (++len > UFS_MAXNAMLEN) {
573199767f8SToomas Soome rc = ENOENT;
574199767f8SToomas Soome goto out;
575199767f8SToomas Soome }
576199767f8SToomas Soome cp++;
577199767f8SToomas Soome }
578199767f8SToomas Soome *cp = '\0';
579199767f8SToomas Soome }
580199767f8SToomas Soome
581199767f8SToomas Soome /*
582199767f8SToomas Soome * Look up component in current directory.
583199767f8SToomas Soome * Save directory inumber in case we find a
584199767f8SToomas Soome * symbolic link.
585199767f8SToomas Soome */
586199767f8SToomas Soome parent_inumber = inumber;
587199767f8SToomas Soome rc = search_directory(ncp, f, &inumber);
588199767f8SToomas Soome *cp = c;
589199767f8SToomas Soome if (rc)
590199767f8SToomas Soome goto out;
591199767f8SToomas Soome
592199767f8SToomas Soome /*
593199767f8SToomas Soome * Open next component.
594199767f8SToomas Soome */
595199767f8SToomas Soome if ((rc = read_inode(inumber, f)) != 0)
596199767f8SToomas Soome goto out;
597199767f8SToomas Soome
598199767f8SToomas Soome /*
599199767f8SToomas Soome * Check for symbolic link.
600199767f8SToomas Soome */
601199767f8SToomas Soome if ((DIP(fp, di_mode) & IFMT) == IFLNK) {
602199767f8SToomas Soome int link_len = DIP(fp, di_size);
603199767f8SToomas Soome int len;
604199767f8SToomas Soome
605199767f8SToomas Soome len = strlen(cp);
606199767f8SToomas Soome
607199767f8SToomas Soome if (link_len + len > MAXPATHLEN ||
608199767f8SToomas Soome ++nlinks > MAXSYMLINKS) {
609199767f8SToomas Soome rc = ENOENT;
610199767f8SToomas Soome goto out;
611199767f8SToomas Soome }
612199767f8SToomas Soome
613199767f8SToomas Soome bcopy(cp, &namebuf[link_len], len + 1);
614199767f8SToomas Soome
615199767f8SToomas Soome if (link_len < fs->fs_maxsymlinklen) {
616199767f8SToomas Soome if (fp->f_fs->fs_magic == FS_UFS1_MAGIC)
617199767f8SToomas Soome cp = (caddr_t)(fp->f_di.di1.di_db);
618199767f8SToomas Soome else
619199767f8SToomas Soome cp = (caddr_t)(fp->f_di.di2.di_db);
6200384eafeSToomas Soome bcopy(cp, namebuf, (unsigned)link_len);
621199767f8SToomas Soome } else {
622199767f8SToomas Soome /*
623199767f8SToomas Soome * Read file for symbolic link
624199767f8SToomas Soome */
625199767f8SToomas Soome size_t buf_size;
626199767f8SToomas Soome ufs2_daddr_t disk_block;
627199767f8SToomas Soome struct fs *fs = fp->f_fs;
628199767f8SToomas Soome
629199767f8SToomas Soome if (!buf)
630199767f8SToomas Soome buf = malloc(fs->fs_bsize);
631199767f8SToomas Soome rc = block_map(f, (ufs2_daddr_t)0, &disk_block);
632199767f8SToomas Soome if (rc)
633199767f8SToomas Soome goto out;
6340384eafeSToomas Soome
635199767f8SToomas Soome twiddle(1);
636199767f8SToomas Soome rc = (f->f_dev->dv_strategy)(f->f_devdata,
6370384eafeSToomas Soome F_READ, fsbtodb(fs, disk_block),
6380384eafeSToomas Soome fs->fs_bsize, buf, &buf_size);
639199767f8SToomas Soome if (rc)
640199767f8SToomas Soome goto out;
641199767f8SToomas Soome
642199767f8SToomas Soome bcopy((char *)buf, namebuf, (unsigned)link_len);
643199767f8SToomas Soome }
644199767f8SToomas Soome
645199767f8SToomas Soome /*
646199767f8SToomas Soome * If relative pathname, restart at parent directory.
647199767f8SToomas Soome * If absolute pathname, restart at root.
648199767f8SToomas Soome */
649199767f8SToomas Soome cp = namebuf;
650199767f8SToomas Soome if (*cp != '/')
651199767f8SToomas Soome inumber = parent_inumber;
652199767f8SToomas Soome else
653199767f8SToomas Soome inumber = (ino_t)ROOTINO;
654199767f8SToomas Soome
655199767f8SToomas Soome if ((rc = read_inode(inumber, f)) != 0)
656199767f8SToomas Soome goto out;
657199767f8SToomas Soome }
658199767f8SToomas Soome }
659199767f8SToomas Soome
660199767f8SToomas Soome /*
661199767f8SToomas Soome * Found terminal component.
662199767f8SToomas Soome */
663199767f8SToomas Soome rc = 0;
664199767f8SToomas Soome fp->f_seekp = 0;
665199767f8SToomas Soome out:
666199767f8SToomas Soome if (buf)
667199767f8SToomas Soome free(buf);
668199767f8SToomas Soome if (path)
669199767f8SToomas Soome free(path);
670199767f8SToomas Soome if (rc) {
671199767f8SToomas Soome if (fp->f_buf)
672199767f8SToomas Soome free(fp->f_buf);
673199767f8SToomas Soome free(fp->f_fs);
674199767f8SToomas Soome free(fp);
675199767f8SToomas Soome }
676199767f8SToomas Soome return (rc);
677199767f8SToomas Soome }
678199767f8SToomas Soome
679199767f8SToomas Soome static int
ufs_close(struct open_file * f)6800384eafeSToomas Soome ufs_close(struct open_file *f)
681199767f8SToomas Soome {
682199767f8SToomas Soome struct file *fp = (struct file *)f->f_fsdata;
683199767f8SToomas Soome int level;
684199767f8SToomas Soome
685199767f8SToomas Soome f->f_fsdata = (void *)0;
686199767f8SToomas Soome if (fp == (struct file *)0)
687199767f8SToomas Soome return (0);
688199767f8SToomas Soome
689199767f8SToomas Soome for (level = 0; level < NIADDR; level++) {
690199767f8SToomas Soome if (fp->f_blk[level])
691199767f8SToomas Soome free(fp->f_blk[level]);
692199767f8SToomas Soome }
693199767f8SToomas Soome if (fp->f_buf)
694199767f8SToomas Soome free(fp->f_buf);
695199767f8SToomas Soome free(fp->f_fs);
696199767f8SToomas Soome free(fp);
697199767f8SToomas Soome return (0);
698199767f8SToomas Soome }
699199767f8SToomas Soome
700199767f8SToomas Soome /*
701199767f8SToomas Soome * Copy a portion of a file into kernel memory.
702199767f8SToomas Soome * Cross block boundaries when necessary.
703199767f8SToomas Soome */
704199767f8SToomas Soome static int
ufs_read(struct open_file * f,void * start,size_t size,size_t * resid)7050384eafeSToomas Soome ufs_read(struct open_file *f, void *start, size_t size, size_t *resid)
706199767f8SToomas Soome {
707199767f8SToomas Soome struct file *fp = (struct file *)f->f_fsdata;
708199767f8SToomas Soome size_t csize;
709199767f8SToomas Soome char *buf;
710199767f8SToomas Soome size_t buf_size;
711199767f8SToomas Soome int rc = 0;
712199767f8SToomas Soome char *addr = start;
713199767f8SToomas Soome
714199767f8SToomas Soome while (size != 0) {
715199767f8SToomas Soome if (fp->f_seekp >= DIP(fp, di_size))
716199767f8SToomas Soome break;
717199767f8SToomas Soome
718199767f8SToomas Soome rc = buf_read_file(f, &buf, &buf_size);
719199767f8SToomas Soome if (rc)
720199767f8SToomas Soome break;
721199767f8SToomas Soome
722199767f8SToomas Soome csize = size;
723199767f8SToomas Soome if (csize > buf_size)
724199767f8SToomas Soome csize = buf_size;
725199767f8SToomas Soome
726199767f8SToomas Soome bcopy(buf, addr, csize);
727199767f8SToomas Soome
728199767f8SToomas Soome fp->f_seekp += csize;
729199767f8SToomas Soome addr += csize;
730199767f8SToomas Soome size -= csize;
731199767f8SToomas Soome }
732199767f8SToomas Soome if (resid)
733199767f8SToomas Soome *resid = size;
734199767f8SToomas Soome return (rc);
735199767f8SToomas Soome }
736199767f8SToomas Soome
737199767f8SToomas Soome /*
738199767f8SToomas Soome * Write to a portion of an already allocated file.
739199767f8SToomas Soome * Cross block boundaries when necessary. Can not
740199767f8SToomas Soome * extend the file.
741199767f8SToomas Soome */
742199767f8SToomas Soome static int
ufs_write(struct open_file * f,const void * start,size_t size,size_t * resid)7430384eafeSToomas Soome ufs_write(struct open_file *f, const void *start, size_t size, size_t *resid)
744199767f8SToomas Soome {
745199767f8SToomas Soome struct file *fp = (struct file *)f->f_fsdata;
746199767f8SToomas Soome size_t csize;
747199767f8SToomas Soome int rc = 0;
748cf837ed8SToomas Soome const char *addr = start;
749199767f8SToomas Soome
750199767f8SToomas Soome csize = size;
751199767f8SToomas Soome while ((size != 0) && (csize != 0)) {
752199767f8SToomas Soome if (fp->f_seekp >= DIP(fp, di_size))
753199767f8SToomas Soome break;
754199767f8SToomas Soome
755199767f8SToomas Soome if (csize >= 512) csize = 512; /* XXX */
756199767f8SToomas Soome
757199767f8SToomas Soome rc = buf_write_file(f, addr, &csize);
758199767f8SToomas Soome if (rc)
759199767f8SToomas Soome break;
760199767f8SToomas Soome
761199767f8SToomas Soome fp->f_seekp += csize;
762199767f8SToomas Soome addr += csize;
763199767f8SToomas Soome size -= csize;
764199767f8SToomas Soome }
765199767f8SToomas Soome if (resid)
766199767f8SToomas Soome *resid = size;
767199767f8SToomas Soome return (rc);
768199767f8SToomas Soome }
769199767f8SToomas Soome
770199767f8SToomas Soome static off_t
ufs_seek(struct open_file * f,off_t offset,int where)7710384eafeSToomas Soome ufs_seek(struct open_file *f, off_t offset, int where)
772199767f8SToomas Soome {
773199767f8SToomas Soome struct file *fp = (struct file *)f->f_fsdata;
774199767f8SToomas Soome
775199767f8SToomas Soome switch (where) {
776199767f8SToomas Soome case SEEK_SET:
777199767f8SToomas Soome fp->f_seekp = offset;
778199767f8SToomas Soome break;
779199767f8SToomas Soome case SEEK_CUR:
780199767f8SToomas Soome fp->f_seekp += offset;
781199767f8SToomas Soome break;
782199767f8SToomas Soome case SEEK_END:
783199767f8SToomas Soome fp->f_seekp = DIP(fp, di_size) - offset;
784199767f8SToomas Soome break;
785199767f8SToomas Soome default:
786199767f8SToomas Soome errno = EINVAL;
787199767f8SToomas Soome return (-1);
788199767f8SToomas Soome }
789199767f8SToomas Soome return (fp->f_seekp);
790199767f8SToomas Soome }
791199767f8SToomas Soome
792199767f8SToomas Soome static int
ufs_stat(struct open_file * f,struct stat * sb)7930384eafeSToomas Soome ufs_stat(struct open_file *f, struct stat *sb)
794199767f8SToomas Soome {
795199767f8SToomas Soome struct file *fp = (struct file *)f->f_fsdata;
796199767f8SToomas Soome
797199767f8SToomas Soome /* only important stuff */
798199767f8SToomas Soome sb->st_mode = DIP(fp, di_mode);
799199767f8SToomas Soome sb->st_uid = DIP(fp, di_uid);
800199767f8SToomas Soome sb->st_gid = DIP(fp, di_gid);
801199767f8SToomas Soome sb->st_size = DIP(fp, di_size);
802199767f8SToomas Soome return (0);
803199767f8SToomas Soome }
804199767f8SToomas Soome
805199767f8SToomas Soome static int
ufs_readdir(struct open_file * f,struct dirent * d)806199767f8SToomas Soome ufs_readdir(struct open_file *f, struct dirent *d)
807199767f8SToomas Soome {
808199767f8SToomas Soome struct file *fp = (struct file *)f->f_fsdata;
809199767f8SToomas Soome struct direct *dp;
810199767f8SToomas Soome char *buf;
811199767f8SToomas Soome size_t buf_size;
812199767f8SToomas Soome int error;
813199767f8SToomas Soome
814199767f8SToomas Soome /*
815199767f8SToomas Soome * assume that a directory entry will not be split across blocks
816199767f8SToomas Soome */
817199767f8SToomas Soome again:
818199767f8SToomas Soome if (fp->f_seekp >= DIP(fp, di_size))
819199767f8SToomas Soome return (ENOENT);
820199767f8SToomas Soome error = buf_read_file(f, &buf, &buf_size);
821199767f8SToomas Soome if (error)
822199767f8SToomas Soome return (error);
823199767f8SToomas Soome dp = (struct direct *)buf;
824199767f8SToomas Soome fp->f_seekp += dp->d_reclen;
825199767f8SToomas Soome if (dp->d_ino == (ino_t)0)
826199767f8SToomas Soome goto again;
827199767f8SToomas Soome
828199767f8SToomas Soome d->d_type = 0; /* illumos ufs does not have type in direct */
829199767f8SToomas Soome strcpy(d->d_name, dp->d_name);
830199767f8SToomas Soome return (0);
831199767f8SToomas Soome }
832