1 /*
2 * This file and its contents are supplied under the terms of the
3 * Common Development and Distribution License ("CDDL"), version 1.0.
4 * You may only use this file in accordance with the terms of version
5 * 1.0 of the CDDL.
6 *
7 * A full copy of the text of the CDDL should have accompanied this
8 * source. A copy of the CDDL is also available via the Internet at
9 * http://www.illumos.org/license/CDDL.
10 */
11
12 /*
13 * Copyright (c) 2015 Joyent, Inc. All rights reserved.
14 */
15
16 /*
17 * bootfs vnode operations
18 */
19
20 #include <sys/types.h>
21 #include <sys/uio.h>
22 #include <sys/sunddi.h>
23 #include <sys/errno.h>
24 #include <sys/vfs_opreg.h>
25 #include <sys/vnode.h>
26 #include <sys/mman.h>
27 #include <fs/fs_subr.h>
28 #include <sys/policy.h>
29 #include <sys/sysmacros.h>
30 #include <sys/dirent.h>
31 #include <sys/uio.h>
32 #include <vm/pvn.h>
33 #include <vm/hat.h>
34 #include <vm/seg_map.h>
35 #include <vm/seg_vn.h>
36 #include <sys/vmsystm.h>
37
38 #include <sys/fs/bootfs_impl.h>
39
40 struct vnodeops *bootfs_vnodeops;
41
42 /*ARGSUSED*/
43 static int
44 bootfs_open(vnode_t **vpp, int flag, cred_t *cr, caller_context_t *ct)
45 {
46 return (0);
47 }
48
49 /*ARGSUSED*/
50 static int
51 bootfs_close(vnode_t *vp, int flag, int count, offset_t offset, cred_t *cr,
52 caller_context_t *ct)
53 {
54 return (0);
55 }
56
57 /*ARGSUSED*/
58 static int
59 bootfs_read(vnode_t *vp, struct uio *uiop, int ioflag, cred_t *cr,
60 caller_context_t *ct)
61 {
62 int err;
63 ssize_t sres = uiop->uio_resid;
64 bootfs_node_t *bnp = vp->v_data;
65
66 if (vp->v_type == VDIR)
67 return (EISDIR);
68
69 if (vp->v_type != VREG)
70 return (EINVAL);
71
72 if (uiop->uio_loffset < 0)
73 return (EINVAL);
74
75 if (uiop->uio_loffset >= bnp->bvn_size)
76 return (0);
77
78 err = 0;
79 while (uiop->uio_resid != 0) {
80 caddr_t base;
81 long offset, frem;
82 ulong_t poff, segoff;
83 size_t bytes;
84 int relerr;
85
86 offset = uiop->uio_loffset;
87 poff = offset & PAGEOFFSET;
88 bytes = MIN(PAGESIZE - poff, uiop->uio_resid);
89
90 frem = bnp->bvn_size - offset;
91 if (frem <= 0) {
92 err = 0;
93 break;
94 }
95
96 /* Don't read past EOF */
97 bytes = MIN(bytes, frem);
98
99 /*
100 * Segmaps are likely larger than our page size, so make sure we
101 * have the proper offfset into the resulting segmap data.
102 */
103 segoff = (offset & PAGEMASK) & MAXBOFFSET;
104
105 base = segmap_getmapflt(segkmap, vp, offset & MAXBMASK, bytes,
106 1, S_READ);
107
108 err = uiomove(base + segoff + poff, bytes, UIO_READ, uiop);
109 relerr = segmap_release(segkmap, base, 0);
110
111 if (err == 0)
112 err = relerr;
113
114 if (err != 0)
115 break;
116 }
117
118 /* Even if we had an error in a partial read, return success */
119 if (uiop->uio_resid > sres)
120 err = 0;
121
122 gethrestime(&bnp->bvn_attr.va_atime);
123
124 return (err);
125 }
126
127 /*ARGSUSED*/
128 static int
129 bootfs_ioctl(vnode_t *vp, int cmd, intptr_t data, int flag,
130 cred_t *cr, int *rvalp, caller_context_t *ct)
131 {
132 return (ENOTTY);
133 }
134
135 /*ARGSUSED*/
136 static int
137 bootfs_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
138 caller_context_t *ct)
139 {
140 uint32_t mask;
141 bootfs_node_t *bpn = (bootfs_node_t *)vp->v_data;
142
143 mask = vap->va_mask;
144 bcopy(&bpn->bvn_attr, vap, sizeof (vattr_t));
145 vap->va_mask = mask;
146 return (0);
147 }
148
149 /*ARGSUSED*/
150 static int
151 bootfs_access(vnode_t *vp, int mode, int flags, cred_t *cr,
152 caller_context_t *ct)
153 {
154 int shift = 0;
155 bootfs_node_t *bpn = (bootfs_node_t *)vp->v_data;
156
157 if (crgetuid(cr) != bpn->bvn_attr.va_uid) {
158 shift += 3;
159 if (groupmember(bpn->bvn_attr.va_gid, cr) == 0)
160 shift += 3;
161 }
162
163 return (secpolicy_vnode_access2(cr, vp, bpn->bvn_attr.va_uid,
164 bpn->bvn_attr.va_mode << shift, mode));
165 }
166
167 /*ARGSUSED*/
168 static int
169 bootfs_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, struct pathname *pnp,
170 int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct,
171 int *direntflags, pathname_t *realpnp)
172 {
173 avl_index_t where;
174 bootfs_node_t sn, *bnp;
175 bootfs_node_t *bpp = (bootfs_node_t *)dvp->v_data;
176
177 if (flags & LOOKUP_XATTR)
178 return (EINVAL);
179
180 if (bpp->bvn_attr.va_type != VDIR)
181 return (ENOTDIR);
182
183 if (*nm == '\0' || strcmp(nm, ".") == 0) {
184 VN_HOLD(dvp);
185 *vpp = dvp;
186 return (0);
187 }
188
189 if (strcmp(nm, "..") == 0) {
190 VN_HOLD(bpp->bvn_parent->bvn_vnp);
191 *vpp = bpp->bvn_parent->bvn_vnp;
192 return (0);
193 }
194
195 sn.bvn_name = nm;
196 bnp = avl_find(&bpp->bvn_dir, &sn, &where);
197 if (bnp == NULL)
198 return (ENOENT);
199
200 VN_HOLD(bnp->bvn_vnp);
201 *vpp = bnp->bvn_vnp;
202 return (0);
203 }
204
205 /*ARGSUSED*/
206 static int
207 bootfs_readdir(vnode_t *vp, struct uio *uiop, cred_t *cr, int *eofp,
208 caller_context_t *ct, int flags)
209 {
210 bootfs_node_t *bnp = (bootfs_node_t *)vp->v_data;
211 dirent64_t *dp;
212 void *buf;
213 ulong_t bsize, brem;
214 offset_t coff, roff;
215 int dlen, ret;
216 bootfs_node_t *dnp;
217 boolean_t first = B_TRUE;
218
219 if (uiop->uio_loffset >= MAXOFF_T) {
220 if (eofp != NULL)
221 *eofp = 1;
222 return (0);
223 }
224
225 if (uiop->uio_iovcnt != 1)
226 return (EINVAL);
227
228 if (!(uiop->uio_iov->iov_len > 0))
229 return (EINVAL);
230
231 if (vp->v_type != VDIR)
232 return (ENOTDIR);
233
234 roff = uiop->uio_loffset;
235 coff = 0;
236 brem = bsize = uiop->uio_iov->iov_len;
237 buf = kmem_alloc(bsize, KM_SLEEP);
238 dp = buf;
239
240 /*
241 * Recall that offsets here are done based on the name of the dirent
242 * excluding the null terminator. Therefore `.` is always at 0, `..` is
243 * always at 1, and then the first real dirent is at 3. This offset is
244 * what's actually stored when we update the offset in the structure.
245 */
246 if (roff == 0) {
247 dlen = DIRENT64_RECLEN(1);
248 if (first == B_TRUE) {
249 if (dlen > brem) {
250 kmem_free(buf, bsize);
251 return (EINVAL);
252 }
253 first = B_FALSE;
254 }
255 dp->d_ino = (ino64_t)bnp->bvn_attr.va_nodeid;
256 dp->d_off = 0;
257 dp->d_reclen = (ushort_t)dlen;
258 (void) strncpy(dp->d_name, ".", DIRENT64_NAMELEN(dlen));
259 dp = (struct dirent64 *)((uintptr_t)dp + dp->d_reclen);
260 brem -= dlen;
261 }
262
263 if (roff <= 1) {
264 dlen = DIRENT64_RECLEN(2);
265 if (first == B_TRUE) {
266 if (dlen > brem) {
267 kmem_free(buf, bsize);
268 return (EINVAL);
269 }
270 first = B_FALSE;
271 }
272 dp->d_ino = (ino64_t)bnp->bvn_parent->bvn_attr.va_nodeid;
273 dp->d_off = 1;
274 dp->d_reclen = (ushort_t)dlen;
275 (void) strncpy(dp->d_name, "..", DIRENT64_NAMELEN(dlen));
276 dp = (struct dirent64 *)((uintptr_t)dp + dp->d_reclen);
277 brem -= dlen;
278 }
279
280 coff = 3;
281 for (dnp = avl_first(&bnp->bvn_dir); dnp != NULL;
282 dnp = AVL_NEXT(&bnp->bvn_dir, dnp)) {
283 size_t nlen = strlen(dnp->bvn_name);
284
285 if (roff > coff) {
286 coff += nlen;
287 continue;
288 }
289
290 dlen = DIRENT64_RECLEN(nlen);
291 if (dlen > brem) {
292 if (first == B_TRUE) {
293 kmem_free(buf, bsize);
294 return (EINVAL);
295 }
296 break;
297 }
298 first = B_FALSE;
299
300 dp->d_ino = (ino64_t)dnp->bvn_attr.va_nodeid;
301 dp->d_off = coff;
302 dp->d_reclen = (ushort_t)dlen;
303 (void) strncpy(dp->d_name, dnp->bvn_name,
304 DIRENT64_NAMELEN(dlen));
305 dp = (struct dirent64 *)((uintptr_t)dp + dp->d_reclen);
306 brem -= dlen;
307 coff += nlen;
308 }
309
310 ret = uiomove(buf, (bsize - brem), UIO_READ, uiop);
311
312 if (ret == 0) {
313 if (dnp == NULL) {
314 coff++;
315 if (eofp != NULL)
316 *eofp = 1;
317 } else if (eofp != NULL) {
318 *eofp = 0;
319 }
320 uiop->uio_loffset = coff;
321 }
322 gethrestime(&bnp->bvn_attr.va_atime);
323 kmem_free(buf, bsize);
324 return (ret);
325 }
326
327 /*ARGSUSED*/
328 static void
329 bootfs_inactive(vnode_t *vp, cred_t *cr, caller_context_t *ct)
330 {
331 }
332
333 /*ARGSUSED*/
334 static int
335 bootfs_rwlock(vnode_t *vp, int write_lock, caller_context_t *ct)
336 {
337 if (write_lock != 0)
338 return (EINVAL);
339 return (0);
340 }
341
342 /*ARGSUSED*/
343 static void
344 bootfs_rwunlock(vnode_t *vp, int write_lock, caller_context_t *ct)
345 {
346 }
347
348 /*ARGSUSED*/
349 static int
350 bootfs_seek(vnode_t *vp, offset_t ooff, offset_t *noffp,
351 caller_context_t *ct)
352 {
353 bootfs_node_t *bnp = (bootfs_node_t *)vp->v_data;
354 if (vp->v_type == VDIR)
355 return (0);
356 return ((*noffp < 0 || *noffp > bnp->bvn_size ? EINVAL : 0));
357 }
358
359 /*
360 * We need to fill in a single page of a vnode's memory based on the actual data
361 * from the kernel. We'll use this node's sliding window into physical memory
362 * and update one page at a time.
363 */
364 /*ARGSUSED*/
365 static int
366 bootfs_getapage(vnode_t *vp, u_offset_t off, size_t len, uint_t *protp,
367 page_t *pl[], size_t plsz, struct seg *seg, caddr_t addr, enum seg_rw rw,
368 cred_t *cr)
369 {
370 bootfs_node_t *bnp = vp->v_data;
371 page_t *pp, *fpp;
372 pfn_t pfn;
373
374 for (;;) {
375 /* Easy case where the page exists */
376 pp = page_lookup(vp, off, rw == S_CREATE ? SE_EXCL : SE_SHARED);
377 if (pp != NULL) {
378 if (pl != NULL) {
379 pl[0] = pp;
380 pl[1] = NULL;
381 } else {
382 page_unlock(pp);
383 }
384 return (0);
385 }
386
387 pp = page_create_va(vp, off, PAGESIZE, PG_EXCL | PG_WAIT, seg,
388 addr);
389
390 /*
391 * If we didn't get the page, that means someone else beat us to
392 * creating this so we need to try again.
393 */
394 if (pp != NULL)
395 break;
396 }
397
398 pfn = btop((bnp->bvn_addr + off) & PAGEMASK);
399 fpp = page_numtopp_nolock(pfn);
400
401 if (ppcopy(fpp, pp) == 0) {
402 pvn_read_done(pp, B_ERROR);
403 return (EIO);
404 }
405
406 if (pl != NULL) {
407 pvn_plist_init(pp, pl, plsz, off, PAGESIZE, rw);
408 } else {
409 pvn_io_done(pp);
410 }
411
412 return (0);
413 }
414
415 /*ARGSUSED*/
416 static int
417 bootfs_getpage(vnode_t *vp, offset_t off, size_t len, uint_t *protp,
418 page_t *pl[], size_t plsz, struct seg *seg, caddr_t addr, enum seg_rw rw,
419 cred_t *cr, caller_context_t *ct)
420 {
421 int err;
422 bootfs_node_t *bnp = vp->v_data;
423
424 if (off + len > bnp->bvn_size + PAGEOFFSET)
425 return (EFAULT);
426
427 if (protp != NULL)
428 *protp = PROT_ALL;
429
430 if (len <= PAGESIZE)
431 err = bootfs_getapage(vp, (u_offset_t)off, len, protp, pl,
432 plsz, seg, addr, rw, cr);
433 else
434 err = pvn_getpages(bootfs_getapage, vp, (u_offset_t)off, len,
435 protp, pl, plsz, seg, addr, rw, cr);
436
437 return (err);
438 }
439
440 /*ARGSUSED*/
441 static int
442 bootfs_map(vnode_t *vp, offset_t off, struct as *as, caddr_t *addrp,
443 size_t len, uchar_t prot, uchar_t maxprot, uint_t flags, cred_t *cr,
444 caller_context_t *ct)
445 {
446 int ret;
447 segvn_crargs_t vn_a;
448
449 #ifdef _ILP32
450 if (len > MAXOFF_T)
451 return (ENOMEM);
452 #endif
453
454 if (vp->v_flag & VNOMAP)
455 return (ENOSYS);
456
457 if (off < 0 || off > MAXOFFSET_T - off)
458 return (ENXIO);
459
460 if (vp->v_type != VREG)
461 return (ENODEV);
462
463 if ((prot & PROT_WRITE) && (flags & MAP_SHARED))
464 return (ENOTSUP);
465
466 as_rangelock(as);
467 ret = choose_addr(as, addrp, len, off, ADDR_VACALIGN, flags);
468 if (ret != 0) {
469 as_rangeunlock(as);
470 return (ret);
471 }
472
473 vn_a.vp = vp;
474 vn_a.offset = (u_offset_t)off;
475 vn_a.type = flags & MAP_TYPE;
476 vn_a.prot = prot;
477 vn_a.maxprot = maxprot;
478 vn_a.cred = cr;
479 vn_a.amp = NULL;
480 vn_a.flags = flags & ~MAP_TYPE;
481 vn_a.szc = 0;
482 vn_a.lgrp_mem_policy_flags = 0;
483
484 ret = as_map(as, *addrp, len, segvn_create, &vn_a);
485
486 as_rangeunlock(as);
487 return (ret);
488
489 }
490
491 /*ARGSUSED*/
492 static int
493 bootfs_addmap(vnode_t *vp, offset_t off, struct as *as, caddr_t addr,
494 size_t len, uchar_t prot, uchar_t maxprot, uint_t flags, cred_t *cr,
495 caller_context_t *ct)
496 {
497 return (0);
498 }
499
500 /*ARGSUSED*/
501 static int
502 bootfs_delmap(vnode_t *vp, offset_t off, struct as *as, caddr_t addr,
503 size_t len, uint_t prot, uint_t maxprot, uint_t flags, cred_t *cr,
504 caller_context_t *ct)
505 {
506 return (0);
507 }
508
509 static int
510 bootfs_pathconf(vnode_t *vp, int cmd, ulong_t *valp, cred_t *cr,
511 caller_context_t *ct)
512 {
513 int ret;
514
515 switch (cmd) {
516 case _PC_TIMESTAMP_RESOLUTION:
517 *valp = 1L;
518 ret = 0;
519 break;
520 default:
521 ret = fs_pathconf(vp, cmd, valp, cr, ct);
522 }
523
524 return (ret);
525 }
526
527 const fs_operation_def_t bootfs_vnodeops_template[] = {
528 { VOPNAME_OPEN, { .vop_open = bootfs_open } },
529 { VOPNAME_CLOSE, { .vop_close = bootfs_close } },
530 { VOPNAME_READ, { .vop_read = bootfs_read } },
531 { VOPNAME_IOCTL, { .vop_ioctl = bootfs_ioctl } },
532 { VOPNAME_GETATTR, { .vop_getattr = bootfs_getattr } },
533 { VOPNAME_ACCESS, { .vop_access = bootfs_access } },
534 { VOPNAME_LOOKUP, { .vop_lookup = bootfs_lookup } },
535 { VOPNAME_READDIR, { .vop_readdir = bootfs_readdir } },
536 { VOPNAME_INACTIVE, { .vop_inactive = bootfs_inactive } },
537 { VOPNAME_RWLOCK, { .vop_rwlock = bootfs_rwlock } },
538 { VOPNAME_RWUNLOCK, { .vop_rwunlock = bootfs_rwunlock } },
539 { VOPNAME_SEEK, { .vop_seek = bootfs_seek } },
540 { VOPNAME_GETPAGE, { .vop_getpage = bootfs_getpage } },
541 { VOPNAME_MAP, { .vop_map = bootfs_map } },
542 { VOPNAME_ADDMAP, { .vop_addmap = bootfs_addmap } },
543 { VOPNAME_DELMAP, { .vop_delmap = bootfs_delmap } },
544 { VOPNAME_PATHCONF, { .vop_pathconf = bootfs_pathconf } },
545 { VOPNAME_VNEVENT, { .vop_vnevent = fs_vnevent_nosupport } },
546 { NULL, { NULL } }
547 };