initial commit
[freebsd-arm:freebsd-arm.git] / boot / zfs / zfs.c
1 /*-
2  * Copyright (c) 2007 Doug Rabson
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  *      $FreeBSD$
27  */
28
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31
32 /*
33  *      Stand-alone file reading package.
34  */
35
36 #include <sys/param.h>
37 #include <sys/disklabel.h>
38 #include <sys/time.h>
39 #include <sys/queue.h>
40 #include <stddef.h>
41 #include <stdarg.h>
42 #include <string.h>
43 #include <stand.h>
44 #include <bootstrap.h>
45
46 #include "zfsimpl.c"
47
48 static int      zfs_open(const char *path, struct open_file *f);
49 static int      zfs_write(struct open_file *f, void *buf, size_t size, size_t *resid);
50 static int      zfs_close(struct open_file *f);
51 static int      zfs_read(struct open_file *f, void *buf, size_t size, size_t *resid);
52 static off_t    zfs_seek(struct open_file *f, off_t offset, int where);
53 static int      zfs_stat(struct open_file *f, struct stat *sb);
54 static int      zfs_readdir(struct open_file *f, struct dirent *d);
55
56 struct devsw zfs_dev;
57
58 struct fs_ops zfs_fsops = {
59         "zfs",
60         zfs_open,
61         zfs_close,
62         zfs_read,
63         zfs_write,
64         zfs_seek,
65         zfs_stat,
66         zfs_readdir
67 };
68
69 /*
70  * In-core open file.
71  */
72 struct file {
73         off_t           f_seekp;        /* seek pointer */
74         dnode_phys_t    f_dnode;
75         uint64_t        f_zap_type;     /* zap type for readdir */
76         uint64_t        f_num_leafs;    /* number of fzap leaf blocks */
77         zap_leaf_phys_t *f_zap_leaf;    /* zap leaf buffer */
78 };
79
80 /*
81  * Open a file.
82  */
83 static int
84 zfs_open(const char *upath, struct open_file *f)
85 {
86         spa_t *spa = (spa_t *) f->f_devdata;
87         struct file *fp;
88         int rc;
89
90         if (f->f_dev != &zfs_dev)
91                 return (EINVAL);
92
93         rc = zfs_mount_pool(spa);
94         if (rc)
95                 return (rc);
96
97         /* allocate file system specific data structure */
98         fp = malloc(sizeof(struct file));
99         bzero(fp, sizeof(struct file));
100         f->f_fsdata = (void *)fp;
101
102         if (spa->spa_root_objset.os_type != DMU_OST_ZFS) {
103                 printf("Unexpected object set type %llu\n",
104                     spa->spa_root_objset.os_type);
105                 rc = EIO;
106                 goto out;
107         }
108
109         rc = zfs_lookup(spa, upath, &fp->f_dnode);
110         if (rc)
111                 goto out;
112
113         fp->f_seekp = 0;
114 out:
115         if (rc) {
116                 f->f_fsdata = NULL;
117                 free(fp);
118         }
119         return (rc);
120 }
121
122 static int
123 zfs_close(struct open_file *f)
124 {
125         struct file *fp = (struct file *)f->f_fsdata;
126
127         dnode_cache_obj = 0;
128         f->f_fsdata = (void *)0;
129         if (fp == (struct file *)0)
130                 return (0);
131
132         free(fp);
133         return (0);
134 }
135
136 /*
137  * Copy a portion of a file into kernel memory.
138  * Cross block boundaries when necessary.
139  */
140 static int
141 zfs_read(struct open_file *f, void *start, size_t size, size_t *resid   /* out */)
142 {
143         spa_t *spa = (spa_t *) f->f_devdata;
144         struct file *fp = (struct file *)f->f_fsdata;
145         const znode_phys_t *zp = (const znode_phys_t *) fp->f_dnode.dn_bonus;
146         size_t n;
147         int rc;
148
149         n = size;
150         if (fp->f_seekp + n > zp->zp_size)
151                 n = zp->zp_size - fp->f_seekp;
152         
153         rc = dnode_read(spa, &fp->f_dnode, fp->f_seekp, start, n);
154         if (rc)
155                 return (rc);
156
157         if (0) {
158             int i;
159             for (i = 0; i < n; i++)
160                 putchar(((char*) start)[i]);
161         }
162         fp->f_seekp += n;
163         if (resid)
164                 *resid = size - n;
165
166         return (0);
167 }
168
169 /*
170  * Don't be silly - the bootstrap has no business writing anything.
171  */
172 static int
173 zfs_write(struct open_file *f, void *start, size_t size, size_t *resid  /* out */)
174 {
175
176         return (EROFS);
177 }
178
179 static off_t
180 zfs_seek(struct open_file *f, off_t offset, int where)
181 {
182         struct file *fp = (struct file *)f->f_fsdata;
183         znode_phys_t *zp = (znode_phys_t *) fp->f_dnode.dn_bonus;
184
185         switch (where) {
186         case SEEK_SET:
187                 fp->f_seekp = offset;
188                 break;
189         case SEEK_CUR:
190                 fp->f_seekp += offset;
191                 break;
192         case SEEK_END:
193                 fp->f_seekp = zp->zp_size - offset;
194                 break;
195         default:
196                 errno = EINVAL;
197                 return (-1);
198         }
199         return (fp->f_seekp);
200 }
201
202 static int
203 zfs_stat(struct open_file *f, struct stat *sb)
204 {
205         struct file *fp = (struct file *)f->f_fsdata;
206         znode_phys_t *zp = (znode_phys_t *) fp->f_dnode.dn_bonus;
207
208         /* only important stuff */
209         sb->st_mode = zp->zp_mode;
210         sb->st_uid = zp->zp_uid;
211         sb->st_gid = zp->zp_gid;
212         sb->st_size = zp->zp_size;
213
214         return (0);
215 }
216
217 static int
218 zfs_readdir(struct open_file *f, struct dirent *d)
219 {
220         spa_t *spa = (spa_t *) f->f_devdata;
221         struct file *fp = (struct file *)f->f_fsdata;
222         znode_phys_t *zp = (znode_phys_t *) fp->f_dnode.dn_bonus;
223         mzap_ent_phys_t mze;
224         size_t bsize = fp->f_dnode.dn_datablkszsec << SPA_MINBLOCKSHIFT;
225         int rc;
226
227         if ((zp->zp_mode >> 12) != 0x4) {
228                 return (ENOTDIR);
229         }
230
231         /*
232          * If this is the first read, get the zap type.
233          */
234         if (fp->f_seekp == 0) {
235                 rc = dnode_read(spa, &fp->f_dnode,
236                                 0, &fp->f_zap_type, sizeof(fp->f_zap_type));
237                 if (rc)
238                         return (rc);
239
240                 if (fp->f_zap_type == ZBT_MICRO) {
241                         fp->f_seekp = offsetof(mzap_phys_t, mz_chunk);
242                 } else {
243                         rc = dnode_read(spa, &fp->f_dnode,
244                                         offsetof(zap_phys_t, zap_num_leafs),
245                                         &fp->f_num_leafs,
246                                         sizeof(fp->f_num_leafs));
247                         if (rc)
248                                 return (rc);
249
250                         fp->f_seekp = bsize;
251                         fp->f_zap_leaf = (zap_leaf_phys_t *)malloc(bsize);
252                         rc = dnode_read(spa, &fp->f_dnode,
253                                         fp->f_seekp,
254                                         fp->f_zap_leaf,
255                                         bsize);
256                         if (rc)
257                                 return (rc);
258                 }
259         }
260
261         if (fp->f_zap_type == ZBT_MICRO) {
262         mzap_next:
263                 if (fp->f_seekp >= bsize)
264                         return (ENOENT);
265
266                 rc = dnode_read(spa, &fp->f_dnode,
267                                 fp->f_seekp, &mze, sizeof(mze));
268                 fp->f_seekp += sizeof(mze);
269
270                 if (!mze.mze_name[0])
271                         goto mzap_next;
272
273                 d->d_fileno = ZFS_DIRENT_OBJ(mze.mze_value);
274                 d->d_type = ZFS_DIRENT_TYPE(mze.mze_value);
275                 strcpy(d->d_name, mze.mze_name);
276                 d->d_namlen = strlen(d->d_name);
277                 return (0);
278         } else {
279                 zap_leaf_t zl;
280                 zap_leaf_chunk_t *zc, *nc;
281                 int chunk;
282                 size_t namelen;
283                 char *p;
284                 uint64_t value;
285
286                 /*
287                  * Initialise this so we can use the ZAP size
288                  * calculating macros.
289                  */
290                 zl.l_bs = ilog2(bsize);
291                 zl.l_phys = fp->f_zap_leaf;
292
293                 /*
294                  * Figure out which chunk we are currently looking at
295                  * and consider seeking to the next leaf. We use the
296                  * low bits of f_seekp as a simple chunk index.
297                  */
298         fzap_next:
299                 chunk = fp->f_seekp & (bsize - 1);
300                 if (chunk == ZAP_LEAF_NUMCHUNKS(&zl)) {
301                         fp->f_seekp = (fp->f_seekp & ~(bsize - 1)) + bsize;
302                         chunk = 0;
303
304                         /*
305                          * Check for EOF and read the new leaf.
306                          */
307                         if (fp->f_seekp >= bsize * fp->f_num_leafs)
308                                 return (ENOENT);
309
310                         rc = dnode_read(spa, &fp->f_dnode,
311                                         fp->f_seekp,
312                                         fp->f_zap_leaf,
313                                         bsize);
314                         if (rc)
315                                 return (rc);
316                 }
317
318                 zc = &ZAP_LEAF_CHUNK(&zl, chunk);
319                 fp->f_seekp++;
320                 if (zc->l_entry.le_type != ZAP_CHUNK_ENTRY)
321                         goto fzap_next;
322
323                 namelen = zc->l_entry.le_name_length;
324                 if (namelen > sizeof(d->d_name))
325                         namelen = sizeof(d->d_name);
326
327                 /*
328                  * Paste the name back together.
329                  */
330                 nc = &ZAP_LEAF_CHUNK(&zl, zc->l_entry.le_name_chunk);
331                 p = d->d_name;
332                 while (namelen > 0) {
333                         int len;
334                         len = namelen;
335                         if (len > ZAP_LEAF_ARRAY_BYTES)
336                                 len = ZAP_LEAF_ARRAY_BYTES;
337                         memcpy(p, nc->l_array.la_array, len);
338                         p += len;
339                         namelen -= len;
340                         nc = &ZAP_LEAF_CHUNK(&zl, nc->l_array.la_next);
341                 }
342                 d->d_name[sizeof(d->d_name) - 1] = 0;
343
344                 /*
345                  * Assume the first eight bytes of the value are
346                  * a uint64_t.
347                  */
348                 value = fzap_leaf_value(&zl, zc);
349
350                 d->d_fileno = ZFS_DIRENT_OBJ(value);
351                 d->d_type = ZFS_DIRENT_TYPE(value);
352                 d->d_namlen = strlen(d->d_name);
353
354                 return (0);
355         }
356 }
357
358 static int
359 vdev_read(vdev_t *vdev, void *priv, off_t offset, void *buf, size_t size)
360 {
361         int fd;
362
363         fd = (uintptr_t) priv;
364         lseek(fd, offset, SEEK_SET);
365         if (read(fd, buf, size) == size) {
366                 return 0;
367         } else {
368                 return (EIO);
369         }
370 }
371
372 /*
373  * Convert a pool guid to a 'unit number' suitable for use with zfs_dev_open.
374  */
375 int
376 zfs_guid_to_unit(uint64_t guid)
377 {
378         spa_t *spa;
379         int unit;
380
381         unit = 0;
382         STAILQ_FOREACH(spa, &zfs_pools, spa_link) {
383                 if (spa->spa_guid == guid)
384                         return unit;
385                 unit++;
386         }
387         return (-1);
388 }
389
390 static int
391 zfs_dev_init(void) 
392 {
393         char devname[512];
394         int unit, slice;
395         int fd;
396
397         /*
398          * Open all the disks we can find and see if we can reconstruct
399          * ZFS pools from them. Bogusly assumes that the disks are named
400          * diskN or diskNsM.
401          */
402         zfs_init();
403         for (unit = 0; unit < 32 /* XXX */; unit++) {
404                 sprintf(devname, "disk%d:", unit);
405                 fd = open(devname, O_RDONLY);
406                 if (fd == -1)
407                         continue;
408
409                 /*
410                  * If we find a vdev, the zfs code will eat the fd, otherwise
411                  * we close it.
412                  */
413                 if (vdev_probe(vdev_read, (void*) (uintptr_t) fd, 0))
414                         close(fd);
415
416                 for (slice = 1; slice <= 128; slice++) {
417                         sprintf(devname, "disk%dp%d:", unit, slice);
418                         fd = open(devname, O_RDONLY);
419                         if (fd == -1) {
420                                 sprintf(devname, "disk%ds%d:", unit, slice);
421                                 fd = open(devname, O_RDONLY);
422                                 if (fd == -1)
423                                         continue;
424                         }
425                         if (vdev_probe(vdev_read, (void*) (uintptr_t) fd, 0))
426                                 close(fd);
427                 }
428         }
429
430         return (0);
431 }
432
433 /*
434  * Print information about ZFS pools
435  */
436 static void
437 zfs_dev_print(int verbose)
438 {
439         spa_t *spa;
440         char line[80];
441         int unit;
442
443         if (verbose) {
444                 spa_all_status();
445                 return;
446         }
447         unit = 0;
448         STAILQ_FOREACH(spa, &zfs_pools, spa_link) {
449                 sprintf(line, "    zfs%d:   %s\n", unit, spa->spa_name);
450                 pager_output(line);
451                 unit++;
452         }
453 }
454
455 /*
456  * Attempt to open the pool described by (dev) for use by (f).
457  */
458 static int 
459 zfs_dev_open(struct open_file *f, ...)
460 {
461         va_list         args;
462         struct devdesc  *dev;
463         int             unit, i;
464         spa_t           *spa;
465
466         va_start(args, f);
467         dev = va_arg(args, struct devdesc*);
468         va_end(args);
469
470         /*
471          * We mostly ignore the stuff that devopen sends us. For now,
472          * use the unit to find a pool - later we will override the
473          * devname parsing so that we can name a pool and a fs within
474          * the pool.
475          */
476         unit = dev->d_unit;
477         
478         i = 0;
479         STAILQ_FOREACH(spa, &zfs_pools, spa_link) {
480                 if (i == unit)
481                         break;
482                 i++;
483         }
484         if (!spa) {
485                 return (ENXIO);
486         }
487
488         f->f_devdata = spa;
489         free(dev);
490         return (0);
491 }
492
493 static int 
494 zfs_dev_close(struct open_file *f)
495 {
496
497         f->f_devdata = NULL;
498         return (0);
499 }
500
501 static int 
502 zfs_dev_strategy(void *devdata, int rw, daddr_t dblk, size_t size, char *buf, size_t *rsize)
503 {
504
505         return (ENOSYS);
506 }
507
508 struct devsw zfs_dev = {
509         .dv_name = "zfs", 
510         .dv_type = DEVT_ZFS, 
511         .dv_init = zfs_dev_init,
512         .dv_strategy = zfs_dev_strategy, 
513         .dv_open = zfs_dev_open, 
514         .dv_close = zfs_dev_close, 
515         .dv_ioctl = noioctl,
516         .dv_print = zfs_dev_print,
517         .dv_cleanup = NULL
518 };