1/*	$NetBSD: v7fs_file_util.c,v 1.3 2011/07/18 21:51:49 apb 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_util.c,v 1.3 2011/07/18 21:51:49 apb Exp $");
38#ifdef _KERNEL
39#include <sys/systm.h>
40#include <sys/param.h>
41#else
42#include <stdio.h>
43#include <string.h>
44#include <errno.h>
45#endif
46
47#include "v7fs.h"
48#include "v7fs_impl.h"
49#include "v7fs_endian.h"
50#include "v7fs_inode.h"
51#include "v7fs_dirent.h"
52#include "v7fs_file.h"
53#include "v7fs_datablock.h"
54
55#ifdef V7FS_FILE_DEBUG
56#define	DPRINTF(fmt, args...)	printf("%s: " fmt, __func__, ##args)
57#else
58#define	DPRINTF(fmt, args...)	((void)0)
59#endif
60
61static int replace_subr(struct v7fs_self *, void *, v7fs_daddr_t, size_t);
62static int lookup_by_number_subr(struct v7fs_self *, void *, v7fs_daddr_t,
63    size_t);
64static int can_dirmove(struct v7fs_self *, v7fs_ino_t, v7fs_ino_t);
65static int lookup_parent_from_dir_subr(struct v7fs_self *, void *,
66    v7fs_daddr_t, size_t);
67
68int
69v7fs_file_link(struct v7fs_self *fs, struct v7fs_inode *parent_dir,
70    struct v7fs_inode *p, const char *name)
71{
72	int error = 0;
73
74	DPRINTF("%d %d %s\n", parent_dir->inode_number, p->inode_number, name);
75	if ((error = v7fs_directory_add_entry(fs, parent_dir, p->inode_number,
76	    name))) {
77		DPRINTF("can't add entry");
78		return error;
79	}
80	p->nlink++;
81	v7fs_inode_writeback(fs, p);
82
83	return 0;
84}
85
86int
87v7fs_file_symlink(struct v7fs_self *fs, struct v7fs_inode *p,
88    const char *target)
89{
90	int error;
91	size_t len = strlen(target) + 1;
92
93	if (len > V7FSBSD_MAXSYMLINKLEN) {/* limited target 512byte pathname */
94		DPRINTF("too long pathname.");
95		return ENAMETOOLONG;
96	}
97
98	if ((error = v7fs_datablock_expand(fs, p, len))) {
99		return error;
100	}
101
102	v7fs_daddr_t blk = p->addr[0];	/* 1block only.  */
103	void *buf;
104	if (!(buf = scratch_read(fs, blk))) {
105		return EIO;
106	}
107
108	strncpy(buf, target, V7FS_BSIZE);
109	if (!fs->io.write(fs->io.cookie, buf, blk)) {
110		scratch_free(fs, buf);
111		return EIO;
112	}
113	scratch_free(fs, buf);
114	v7fs_inode_writeback(fs, p);
115
116	return 0;
117}
118
119int
120v7fs_file_rename(struct v7fs_self *fs, struct v7fs_inode *parent_from,
121    const char *from, struct v7fs_inode *parent_to, const char *to)
122{
123	v7fs_ino_t from_ino, to_ino;
124	struct v7fs_inode inode;
125	int error;
126	bool dir_move;
127
128	/* Check source file */
129	if ((error = v7fs_file_lookup_by_name(fs, parent_from, from,
130	    &from_ino))) {
131		DPRINTF("%s don't exists\n", from);
132		return error;
133	}
134	v7fs_inode_load(fs, &inode, from_ino);
135	dir_move = v7fs_inode_isdir(&inode);
136
137	/* Check target file */
138	error = v7fs_file_lookup_by_name(fs, parent_to, to, &to_ino);
139	if (error == 0) {	/* found */
140		DPRINTF("%s already exists\n", to);
141		if ((error = v7fs_file_deallocate(fs, parent_to, to))) {
142			DPRINTF("%s can't remove %d\n", to, error);
143			return error;
144		}
145	} else if (error != ENOENT) {
146		DPRINTF("error=%d\n", error);
147		return error;
148	}
149	/* Check directory hierarchy. t_vnops rename_dir(5) */
150	if (dir_move && (error = can_dirmove(fs, from_ino,
151	    parent_to->inode_number))) {
152		DPRINTF("dst '%s' is child dir of '%s'. error=%d\n", to, from,
153		    error);
154		return error;
155	}
156
157	if ((error = v7fs_directory_add_entry(fs, parent_to, from_ino, to))) {
158		DPRINTF("can't add entry");
159		return error;
160	}
161
162	if ((error = v7fs_directory_remove_entry(fs, parent_from, from))) {
163		DPRINTF("can't remove entry");
164		return error;
165	}
166
167	if (dir_move && (parent_from != parent_to)) {
168		/* If directory move, update ".." */
169		if ((error = v7fs_directory_replace_entry(fs, &inode, "..",
170			    parent_to->inode_number))) {
171			DPRINTF("can't replace parent dir");
172			return error;
173		}
174		v7fs_inode_writeback(fs, &inode);
175	}
176
177	return 0;
178}
179
180
181int
182v7fs_directory_replace_entry(struct v7fs_self *fs,  struct v7fs_inode *self_dir,
183    const char *name, v7fs_ino_t ino)
184{
185	int error;
186
187	/* Search entry that replaced. replace it to new inode number. */
188	struct v7fs_lookup_arg lookup_arg = { .name = name,
189					      .inode_number = ino };
190	if ((error = v7fs_datablock_foreach(fs, self_dir, replace_subr,
191	    &lookup_arg)) != V7FS_ITERATOR_BREAK)
192		return ENOENT;
193
194	return 0;
195}
196
197static int
198replace_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk, size_t sz)
199{
200	struct v7fs_lookup_arg *p = (struct v7fs_lookup_arg *)ctx;
201	struct v7fs_dirent *dir;
202	void *buf;
203	size_t i, n;
204	int ret = 0;
205
206	DPRINTF("match start blk=%x\n", blk);
207	if (!(buf = scratch_read(fs, blk)))
208		return EIO;
209
210	dir = (struct v7fs_dirent *)buf;
211	n = sz / sizeof(*dir);
212
213	for (i = 0; i < n; i++, dir++) { /*disk endian */
214		if (strncmp(p->name, (const char *)dir->name, V7FS_NAME_MAX)
215		    == 0) {
216			/* Replace inode# */
217			dir->inode_number = V7FS_VAL16(fs, p->inode_number);
218			/* Write back. */
219			if (!fs->io.write(fs->io.cookie, buf, blk))
220				ret = EIO;
221			else
222				ret = V7FS_ITERATOR_BREAK;
223			break;
224		}
225	}
226	scratch_free(fs, buf);
227
228	return ret;
229}
230
231bool
232v7fs_file_lookup_by_number(struct v7fs_self *fs, struct v7fs_inode *parent_dir,
233    v7fs_ino_t ino, char *buf)
234{
235	int ret;
236
237	ret = v7fs_datablock_foreach(fs, parent_dir, lookup_by_number_subr,
238	    &(struct v7fs_lookup_arg){ .inode_number = ino, .buf = buf });
239
240	return ret == V7FS_ITERATOR_BREAK;
241}
242
243static int
244lookup_by_number_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk,
245    size_t sz)
246{
247	struct v7fs_lookup_arg *p = (struct v7fs_lookup_arg *)ctx;
248	struct v7fs_dirent *dir;
249	void *buf;
250	size_t i, n;
251	int ret = 0;
252
253	if (!(buf = scratch_read(fs, blk)))
254		return EIO;
255
256	dir = (struct v7fs_dirent *)buf;
257	n = sz / sizeof(*dir);
258	v7fs_dirent_endian_convert(fs, dir, n);
259
260	for (i = 0; i < n; i++, dir++) {
261		if (dir->inode_number == p->inode_number) {
262			if (p->buf)
263				v7fs_dirent_filename(p->buf, dir->name);
264			ret = V7FS_ITERATOR_BREAK;
265			break;
266		}
267	}
268	scratch_free(fs, buf);
269
270	return ret;
271}
272
273struct lookup_parent_arg {
274	v7fs_ino_t parent_ino;
275};
276
277static int
278can_dirmove(struct v7fs_self *fs, v7fs_ino_t from_ino, v7fs_ino_t to_ino)
279{
280	struct v7fs_inode inode;
281	v7fs_ino_t parent;
282	int error;
283
284	/* Start dir. */
285	if ((error = v7fs_inode_load(fs, &inode, to_ino)))
286		return error;
287
288	if (!v7fs_inode_isdir(&inode))
289		return ENOTDIR;
290
291	/* Lookup the parent. */
292	do {
293		struct lookup_parent_arg arg;
294		/* Search parent dir */
295		arg.parent_ino = 0;
296		v7fs_datablock_foreach(fs, &inode, lookup_parent_from_dir_subr,
297		    &arg);
298		if ((parent = arg.parent_ino) == 0) {
299			DPRINTF("***parent missing\n");
300			return ENOENT;
301		}
302		/* Load parent dir */
303		if ((error = v7fs_inode_load(fs, &inode, parent)))
304			return error;
305		if (parent == from_ino) {
306			DPRINTF("#%d is child dir of #%d\n", to_ino, from_ino);
307			return EINVAL;
308		}
309	} while (parent != V7FS_ROOT_INODE);
310
311	return 0;
312}
313
314static int
315lookup_parent_from_dir_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk,
316    size_t sz)
317{
318	struct lookup_parent_arg *arg = (struct lookup_parent_arg *)ctx;
319	char name[V7FS_NAME_MAX + 1];
320	void *buf;
321	int ret = 0;
322
323	if (!(buf = scratch_read(fs, blk)))
324		return 0;
325	struct v7fs_dirent *dir = (struct v7fs_dirent *)buf;
326	size_t i, n = sz / sizeof(*dir);
327	if (!v7fs_dirent_endian_convert(fs, dir, n)) {
328		scratch_free(fs, buf);
329		return V7FS_ITERATOR_ERROR;
330	}
331
332	for (i = 0; i < n; i++, dir++) {
333		v7fs_dirent_filename(name, dir->name);
334		if (strncmp(dir->name, "..", V7FS_NAME_MAX) != 0)
335			continue;
336
337		arg->parent_ino = dir->inode_number;
338		ret = V7FS_ITERATOR_BREAK;
339		break;
340	}
341
342	scratch_free(fs, buf);
343	return ret;
344}
345