Home | History | Annotate | Line # | Download | only in v7fs
v7fs_file.c revision 1.3.8.1
      1 /*	$NetBSD: v7fs_file.c,v 1.3.8.1 2012/12/16 18:24:18 riz Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2011 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by UCHIYAMA Yasushi.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 #if HAVE_NBTOOL_CONFIG_H
     33 #include "nbtool_config.h"
     34 #endif
     35 
     36 #include <sys/cdefs.h>
     37 __KERNEL_RCSID(0, "$NetBSD: v7fs_file.c,v 1.3.8.1 2012/12/16 18:24:18 riz Exp $");
     38 #if defined _KERNEL_OPT
     39 #include "opt_v7fs.h"
     40 #endif
     41 
     42 #ifdef _KERNEL
     43 #include <sys/systm.h>
     44 #include <sys/param.h>
     45 #else
     46 #include <stdio.h>
     47 #include <string.h>
     48 #include <errno.h>
     49 #define	MIN(a,b)	((/*CONSTCOND*/(a)<(b))?(a):(b))
     50 #endif
     51 
     52 #include "v7fs.h"
     53 #include "v7fs_impl.h"
     54 #include "v7fs_endian.h"
     55 #include "v7fs_inode.h"
     56 #include "v7fs_dirent.h"
     57 #include "v7fs_file.h"
     58 #include "v7fs_datablock.h"
     59 
     60 #ifdef V7FS_FILE_DEBUG
     61 #define	DPRINTF(fmt, args...)	printf("%s: " fmt, __func__, ##args)
     62 #else
     63 #define	DPRINTF(fmt, args...)	((void)0)
     64 #endif
     65 
     66 static int lookup_subr(struct v7fs_self *, void *, v7fs_daddr_t, size_t);
     67 static int remove_subr(struct v7fs_self *, void *, v7fs_daddr_t, size_t);
     68 
     69 int
     70 v7fs_file_lookup_by_name(struct v7fs_self *fs, struct v7fs_inode *parent_dir,
     71     const char *name, v7fs_ino_t *ino)
     72 {
     73 	char filename[V7FS_NAME_MAX + 1];
     74 	char *q;
     75 	int error;
     76 	size_t len;
     77 
     78 	if ((q = strchr(name, '/'))) {
     79 		/* Zap following path. */
     80 		len = MIN(V7FS_NAME_MAX, q - name);
     81 		memcpy(filename, name, len);
     82 		filename[len] = '\0';	/* '/' -> '\0' */
     83 	} else {
     84 		v7fs_dirent_filename(filename, name);
     85 	}
     86 	DPRINTF("%s(%s) dir=%d\n", filename, name, parent_dir->inode_number);
     87 
     88 	struct v7fs_lookup_arg lookup_arg = { .name = filename,
     89 					      .inode_number = 0 };
     90 	if ((error = v7fs_datablock_foreach(fs, parent_dir, lookup_subr,
     91 		    &lookup_arg)) != V7FS_ITERATOR_BREAK) {
     92 		DPRINTF("not found.\n");
     93 		return ENOENT;
     94 	}
     95 
     96 	*ino = lookup_arg.inode_number;
     97 	DPRINTF("done. ino=%d\n", *ino);
     98 
     99 	return 0;
    100 }
    101 
    102 static int
    103 lookup_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk, size_t sz)
    104 {
    105 	struct v7fs_lookup_arg *p = (struct v7fs_lookup_arg *)ctx;
    106 	struct v7fs_dirent *dir;
    107 	const char *name = p->name;
    108 	void *buf;
    109 	size_t i, n;
    110 	int ret = 0;
    111 
    112 	if (!(buf = scratch_read(fs, blk)))
    113 		return EIO;
    114 
    115 	dir = (struct v7fs_dirent *)buf;
    116 	n = sz / sizeof(*dir);
    117 	v7fs_dirent_endian_convert(fs, dir, n);
    118 
    119 	for (i = 0; i < n; i++, dir++) {
    120 		if (dir->inode_number < 1) {
    121 			DPRINTF("*** bad inode #%d ***\n", dir->inode_number);
    122 			continue;
    123 		}
    124 
    125 		if (strncmp((const char *)dir->name, name, V7FS_NAME_MAX) == 0)
    126 		{
    127 			p->inode_number = dir->inode_number;
    128 			ret =  V7FS_ITERATOR_BREAK; /* found */
    129 			break;
    130 		}
    131 	}
    132 	scratch_free(fs, buf);
    133 
    134 	return ret;
    135 }
    136 
    137 int
    138 v7fs_file_allocate(struct v7fs_self *fs, struct v7fs_inode *parent_dir,
    139     const char *srcname, struct v7fs_fileattr *attr, v7fs_ino_t *ino)
    140 {
    141 	struct v7fs_inode inode;
    142 	char filename[V7FS_NAME_MAX + 1];
    143 	struct v7fs_dirent *dir;
    144 	int error;
    145 
    146 	/* Truncate filename. */
    147 	v7fs_dirent_filename(filename, srcname);
    148 	DPRINTF("%s(%s)\n", filename, srcname);
    149 
    150 	/* Check filename. */
    151 	if (v7fs_file_lookup_by_name(fs, parent_dir, filename, ino) == 0) {
    152 		DPRINTF("%s exists\n", filename);
    153 		return EEXIST;
    154 	}
    155 
    156 	/* Get new inode. */
    157 	if ((error = v7fs_inode_allocate(fs, ino)))
    158 		return error;
    159 
    160 	/* Set initial attribute. */
    161 	memset(&inode, 0, sizeof(inode));
    162 	inode.inode_number = *ino;
    163 	inode.mode = attr->mode;
    164 	inode.uid = attr->uid;
    165 	inode.gid = attr->gid;
    166 	if (attr->ctime)
    167 		inode.ctime = attr->ctime;
    168 	if (attr->mtime)
    169 		inode.mtime = attr->mtime;
    170 	if (attr->atime)
    171 		inode.atime = attr->atime;
    172 
    173 	switch (inode.mode & V7FS_IFMT)	{
    174 	default:
    175 		DPRINTF("Can't allocate %o type.\n", inode.mode);
    176 		v7fs_inode_deallocate(fs, *ino);
    177 		return EINVAL;
    178 	case V7FS_IFCHR:
    179 		/* FALLTHROUGH */
    180 	case V7FS_IFBLK:
    181 		inode.nlink = 1;
    182 		inode.device = attr->device;
    183 		inode.addr[0] = inode.device;
    184 		break;
    185 	case V7FSBSD_IFFIFO:
    186 		/* FALLTHROUGH */
    187 	case V7FSBSD_IFSOCK:
    188 		/* FALLTHROUGH */
    189 	case V7FSBSD_IFLNK:
    190 		/* FALLTHROUGH */
    191 	case V7FS_IFREG:
    192 		inode.nlink = 1;
    193 		break;
    194 	case V7FS_IFDIR:
    195 		inode.nlink = 2;	/* . + .. */
    196 		if ((error = v7fs_datablock_expand(fs, &inode, sizeof(*dir) * 2
    197 		    ))) {
    198 			v7fs_inode_deallocate(fs, *ino);
    199 			return error;
    200 		}
    201 		v7fs_daddr_t blk = inode.addr[0];
    202 		void *buf;
    203 		if (!(buf = scratch_read(fs, blk))) {
    204 			v7fs_inode_deallocate(fs, *ino);
    205 			return EIO;
    206 		}
    207 		dir = (struct v7fs_dirent *)buf;
    208 		strcpy(dir[0].name, ".");
    209 		dir[0].inode_number = V7FS_VAL16(fs, *ino);
    210 		strcpy(dir[1].name, "..");
    211 		dir[1].inode_number = V7FS_VAL16(fs, parent_dir->inode_number);
    212 		if (!fs->io.write(fs->io.cookie, buf, blk)) {
    213 			scratch_free(fs, buf);
    214 			return EIO;
    215 		}
    216 		scratch_free(fs, buf);
    217 		break;
    218 	}
    219 
    220 	v7fs_inode_writeback(fs, &inode);
    221 
    222 	/* Link this inode to parent directory. */
    223 	if ((error = v7fs_directory_add_entry(fs, parent_dir, *ino, filename)))
    224 	{
    225 		DPRINTF("can't add dirent.\n");
    226 		return error;
    227 	}
    228 
    229 	return 0;
    230 }
    231 
    232 int
    233 v7fs_file_deallocate(struct v7fs_self *fs, struct v7fs_inode *parent_dir,
    234     const char *name)
    235 {
    236 	v7fs_ino_t ino;
    237 	struct v7fs_inode inode;
    238 	int error;
    239 
    240 	DPRINTF("%s\n", name);
    241 	if ((error = v7fs_file_lookup_by_name(fs, parent_dir, name, &ino))) {
    242 		DPRINTF("no such a file: %s\n", name);
    243 		return error;
    244 	}
    245 	DPRINTF("%s->#%d\n", name, ino);
    246 	if ((error = v7fs_inode_load(fs, &inode, ino)))
    247 		return error;
    248 
    249 	if (v7fs_inode_isdir(&inode)) {
    250 		char filename[V7FS_NAME_MAX + 1];
    251 		v7fs_dirent_filename(filename, name);
    252 		/* Check parent */
    253 		if (strncmp(filename, "..", V7FS_NAME_MAX) == 0) {
    254 			DPRINTF("can not remove '..'\n");
    255 			return EINVAL; /* t_vnops rename_dotdot */
    256 		}
    257 		/* Check empty */
    258 		if (v7fs_inode_filesize(&inode) !=
    259 		    sizeof(struct v7fs_dirent) * 2 /*"." + ".."*/) {
    260 			DPRINTF("directory not empty.\n");
    261 			return ENOTEMPTY;/* t_vnops dir_noempty, rename_dir(6)*/
    262 		}
    263 		inode.nlink = 0;	/* remove this. */
    264 	} else {
    265 		/* Decrement reference count. */
    266 		--inode.nlink;	/* regular file. */
    267 		DPRINTF("%s nlink=%d\n", name, inode.nlink);
    268 	}
    269 
    270 
    271 	if ((error = v7fs_directory_remove_entry(fs, parent_dir, name)))
    272 		return error;
    273 	DPRINTF("remove dirent\n");
    274 
    275 	if (inode.nlink == 0) {
    276 		v7fs_datablock_contract(fs, &inode, inode.filesize);
    277 		DPRINTF("remove datablock\n");
    278 		v7fs_inode_deallocate(fs, ino);
    279 		DPRINTF("remove inode\n");
    280 	} else {
    281 		v7fs_inode_writeback(fs, &inode);
    282 	}
    283 
    284 	return 0;
    285 }
    286 
    287 int
    288 v7fs_directory_add_entry(struct v7fs_self *fs, struct v7fs_inode *parent_dir,
    289     v7fs_ino_t ino, const char *srcname)
    290 {
    291 	struct v7fs_inode inode;
    292 	struct v7fs_dirent *dir;
    293 	int error = 0;
    294 	v7fs_daddr_t blk;
    295 	void *buf;
    296 	char filename[V7FS_NAME_MAX + 1];
    297 
    298 	/* Truncate filename. */
    299 	v7fs_dirent_filename(filename, srcname);
    300 	DPRINTF("%s(%s) %d\n", filename, srcname, ino);
    301 
    302 	/* Target inode */
    303 	if ((error = v7fs_inode_load(fs, &inode, ino)))
    304 		return error;
    305 
    306 	/* Expand datablock. */
    307 	if ((error = v7fs_datablock_expand(fs, parent_dir, sizeof(*dir))))
    308 		return error;
    309 
    310 	/* Read last entry. */
    311 	if (!(blk = v7fs_datablock_last(fs, parent_dir,
    312 	    v7fs_inode_filesize(parent_dir))))
    313 		return EIO;
    314 
    315 	/* Load dirent block. This vnode(parent dir) is locked by VFS layer. */
    316 	if (!(buf = scratch_read(fs, blk)))
    317 		return EIO;
    318 
    319 	size_t sz = v7fs_inode_filesize(parent_dir);
    320 	sz = V7FS_RESIDUE_BSIZE(sz);	/* last block payload. */
    321 	int n = sz / sizeof(*dir) - 1;
    322 	/* Add dirent. */
    323 	dir = (struct v7fs_dirent *)buf;
    324 	dir[n].inode_number = V7FS_VAL16(fs, ino);
    325 	memcpy((char *)dir[n].name, filename, V7FS_NAME_MAX);
    326 	/* Write back datablock */
    327 	if (!fs->io.write(fs->io.cookie, buf, blk))
    328 		error = EIO;
    329 	scratch_free(fs, buf);
    330 
    331 	if (v7fs_inode_isdir(&inode)) {
    332 		parent_dir->nlink++;
    333 		v7fs_inode_writeback(fs, parent_dir);
    334 	}
    335 
    336 	DPRINTF("done. (dirent size=%dbyte)\n", parent_dir->filesize);
    337 
    338 	return error;
    339 }
    340 
    341 int
    342 v7fs_directory_remove_entry(struct v7fs_self *fs, struct v7fs_inode *parent_dir,
    343     const char *name)
    344 {
    345 	struct v7fs_inode inode;
    346 	int error;
    347 	struct v7fs_dirent lastdirent;
    348 	v7fs_daddr_t lastblk;
    349 	size_t sz, lastsz;
    350 	v7fs_off_t pos;
    351 	void *buf;
    352 
    353 	/* Setup replaced entry. */
    354 	sz = parent_dir->filesize;
    355 	lastblk = v7fs_datablock_last(fs, parent_dir,
    356 	    v7fs_inode_filesize(parent_dir));
    357 	lastsz = V7FS_RESIDUE_BSIZE(sz);
    358 	pos = lastsz - sizeof(lastdirent);
    359 
    360 	if (!(buf = scratch_read(fs, lastblk)))
    361 		return EIO;
    362 	lastdirent = *((struct v7fs_dirent *)((uint8_t *)buf + pos));
    363 	scratch_free(fs, buf);
    364 	DPRINTF("last dirent=%d %s pos=%d\n",
    365 	    V7FS_VAL16(fs, lastdirent.inode_number), lastdirent.name, pos);
    366 
    367 	struct v7fs_lookup_arg lookup_arg =
    368 	    { .name = name, .replace = &lastdirent/*disk endian */ };
    369 	/* Search entry that removed. replace it to last dirent. */
    370 	if ((error = v7fs_datablock_foreach(fs, parent_dir, remove_subr,
    371 	    &lookup_arg)) != V7FS_ITERATOR_BREAK)
    372 		return ENOENT;
    373 
    374 	/* Contract dirent entries. */
    375 	v7fs_datablock_contract(fs, parent_dir, sizeof(lastdirent));
    376 	DPRINTF("done. (dirent size=%dbyte)\n", parent_dir->filesize);
    377 
    378 	/* Target inode */
    379 	if ((error = v7fs_inode_load(fs, &inode, lookup_arg.inode_number)))
    380 		return error;
    381 
    382 	if (v7fs_inode_isdir(&inode)) {
    383 		parent_dir->nlink--;
    384 		v7fs_inode_writeback(fs, parent_dir);
    385 	}
    386 
    387 	return 0;
    388 }
    389 
    390 static int
    391 remove_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk, size_t sz)
    392 {
    393 	struct v7fs_lookup_arg *p = (struct v7fs_lookup_arg *)ctx;
    394 	struct v7fs_dirent *dir;
    395 	void *buf;
    396 	size_t i;
    397 	int ret = 0;
    398 
    399 	DPRINTF("match start blk=%x\n", blk);
    400 	if (!(buf = scratch_read(fs, blk)))
    401 		return EIO;
    402 
    403 	dir = (struct v7fs_dirent *)buf;
    404 
    405 	for (i = 0; i < sz / sizeof(*dir); i++, dir++) {
    406 		DPRINTF("%d\n", V7FS_VAL16(fs, dir->inode_number));
    407 		if (strncmp(p->name,
    408 			(const char *)dir->name, V7FS_NAME_MAX) == 0) {
    409 			p->inode_number = V7FS_VAL16(fs, dir->inode_number);
    410 			/* Replace to last dirent. */
    411 			*dir = *(p->replace); /* disk endian */
    412 			/* Write back. */
    413 			if (!fs->io.write(fs->io.cookie, buf, blk))
    414 				ret = EIO;
    415 			else
    416 				ret = V7FS_ITERATOR_BREAK;
    417 			break;
    418 		}
    419 	}
    420 	scratch_free(fs, buf);
    421 
    422 	return ret;
    423 }
    424