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