1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #pragma ident "%Z%%M% %I% %E% SMI"
27
28 #include <fs/fs_subr.h>
29
30 #include <sys/elf.h>
31 #include <sys/errno.h>
32 #include <sys/file.h>
33 #include <sys/kmem.h>
34 #include <sys/kobj.h>
35 #include <sys/objfs.h>
36 #include <sys/objfs_impl.h>
37 #include <sys/stat.h>
38 #include <sys/systm.h>
39 #include <sys/sysmacros.h>
40 #include <sys/vfs_opreg.h>
41
42 /*
43 * /system/object/<obj>/object
44 *
45 * This is an ELF file that contains information about data stored in the
46 * kernel. We use a special ELF file type, ET_SUNWPSEUDO, so that we can
47 * control which fields and sections have meaning. The file contains the
48 * following sections:
49 *
50 * .shstrtab Section header string table
51 * .SUNW_ctf CTF data
52 * .symtab Symbol table
53 * .strtab String table
54 * .text Text
55 * .data Data
56 * .bss BSS
57 * .filename Filename of module
58 * .info Private module info structure
59 *
60 * The .text, .data, and .bss sections are all marked SHT_NOBITS, and the data
61 * is not actually exported in the file for security reasons. The section
62 * headers do contain the address and size of the sections, which is needed by
63 * DTrace. The CTF data, symbol table, and string table are present only if
64 * they exist in the kernel.
65 */
66
67 typedef enum {
68 SECT_TYPE_DATA,
69 SECT_TYPE_SHSTRTAB,
70 SECT_TYPE_DUMMY,
71 SECT_TYPE_SYMTAB,
72 SECT_TYPE_STRTAB,
73 SECT_TYPE_FILENAME,
74 SECT_TYPE_INFO
75 } sect_type_t;
76
77 typedef struct section_desc {
78 sect_type_t sect_id;
79 const char *sect_name;
80 uintptr_t sect_addr;
81 size_t sect_size;
82 int sect_type;
83 int sect_flags;
84 size_t sect_str;
85 int sect_link;
86 int sect_entsize;
87 int sect_align;
88 } section_desc_t;
89
90 /*
91 * For data sections, 'addr' and 'size' refer to offsets within the module
92 * structure where we can find the address and size of the section.
93 */
94 #define SECT_DATA(name, addr, size, type, flags, align) \
95 { SECT_TYPE_DATA, name, offsetof(struct module, addr), \
96 offsetof(struct module, size), type, flags, 0, 0, 0, align }
97
98 /*
99 * The dummy section is the initial section of the file. It is put into this
100 * array only for convenience when reading the file.
101 */
102 #define SECT_DUMMY { SECT_TYPE_DUMMY, "", 0, 0, 0, 0, 0, 0, 0, 0 }
103
104 /*
105 * The size of the symbol table and string table are not immediately available
106 * as an offset into the module struct, so we have to create individual types
107 * for each.
108 */
109 #ifdef _LP64
110 #define SECT_SYMTAB(name, type, flags) \
111 { SECT_TYPE_SYMTAB, name, offsetof(struct module, symtbl), 0, type, \
112 flags, 0, 0, sizeof (Elf64_Sym), sizeof (uint64_t) }
113 #else
114 #define SECT_SYMTAB(name, type, flags) \
115 { SECT_TYPE_SYMTAB, name, offsetof(struct module, symtbl), 0, type, \
116 flags, 0, 0, sizeof (Elf32_Sym), sizeof (uint32_t) }
117 #endif
118 #define SECT_STRTAB(name, type, flags) \
119 { SECT_TYPE_STRTAB, name, offsetof(struct module, strings), 0, type, \
120 flags, 0, 0, 0, 1 }
121
122 /*
123 * The .shstrtab section is constructed when the module is first loaded.
124 */
125 #define SECT_SHSTRTAB(name, type, flags) \
126 { SECT_TYPE_SHSTRTAB, name, 0, 0, type, flags, 0, 0, 0, 1 }
127
128 /*
129 * Generic module information (objfs_info_t)
130 */
131 #define SECT_INFO \
132 { SECT_TYPE_INFO, ".info", 0, 0, SHT_PROGBITS, 0, 0, 0, 0, \
133 sizeof (uint32_t) }
134
135 /*
136 * Filename section.
137 */
138 #define SECT_FILENAME \
139 { SECT_TYPE_FILENAME, ".filename", 0, 0, SHT_PROGBITS, 0, 0, 0, 0, 1 }
140
141 static section_desc_t data_sections[] = {
142 SECT_DUMMY,
143 SECT_SHSTRTAB(".shstrtab",
144 SHT_STRTAB, SHF_STRINGS),
145 SECT_DATA(".SUNW_ctf", ctfdata, ctfsize,
146 SHT_PROGBITS, 0, sizeof (uint64_t)),
147 SECT_SYMTAB(".symtab", SHT_SYMTAB, 0),
148 SECT_STRTAB(".strtab", SHT_STRTAB, SHF_STRINGS),
149 SECT_DATA(".text", text, text_size,
150 SHT_NOBITS, SHF_ALLOC | SHF_EXECINSTR, 0),
151 SECT_DATA(".data", data, data_size,
152 SHT_NOBITS, SHF_WRITE | SHF_ALLOC, 0),
153 SECT_DATA(".bss", bss, bss_size,
154 SHT_NOBITS, SHF_WRITE | SHF_ALLOC, 0),
155 SECT_INFO,
156 SECT_FILENAME
157 };
158
159 #define NSECTIONS \
160 (sizeof (data_sections) / sizeof (section_desc_t))
161
162 #ifdef _LP64
163 #define SECTION_OFFSET(section) \
164 (sizeof (Elf64_Ehdr) + (section) * sizeof (Elf64_Shdr))
165 #else
166 #define SECTION_OFFSET(section) \
167 (sizeof (Elf32_Ehdr) + (section) * sizeof (Elf32_Shdr))
168 #endif
169
170 /*
171 * Given a data node, returns the struct module appropriately locked. If the
172 * object has been unloaded, or re-loaded since the file was first opened, this
173 * function will return NULL. If successful, the caller must call
174 * objfs_data_unlock().
175 */
176 struct module *
objfs_data_lock(vnode_t * vp)177 objfs_data_lock(vnode_t *vp)
178 {
179 objfs_datanode_t *dnode = vp->v_data;
180 objfs_odirnode_t *odir = gfs_file_parent(vp)->v_data;
181 struct modctl *mp = odir->objfs_odir_modctl;
182
183 (void) mod_hold_by_modctl(mp, MOD_WAIT_FOREVER | MOD_LOCK_NOT_HELD);
184
185 if (mp->mod_mp == NULL ||
186 dnode->objfs_data_gencount < mp->mod_gencount) {
187 mod_release_mod(mp);
188 return (NULL);
189 }
190
191 return (mp->mod_mp);
192 }
193
194 void
objfs_data_unlock(vnode_t * vp)195 objfs_data_unlock(vnode_t *vp)
196 {
197 objfs_odirnode_t *odir = gfs_file_parent(vp)->v_data;
198
199 mod_release_mod(odir->objfs_odir_modctl);
200 }
201
202
203 /*
204 * Called when the filesystem is first loaded. Creates and initializes the
205 * section header string table, and fills in the sect_str members of the section
206 * descriptors. This information could be encoded at compile-time, but this
207 * way keeps the code more maintainable, as we don't have to worry about
208 * duplicating information.
209 */
210 void
objfs_data_init(void)211 objfs_data_init(void)
212 {
213 int i, shstrtab, strtab, symtab;
214 size_t len = 0;
215 section_desc_t *sect;
216 char *strdata;
217
218 for (i = 0; i < NSECTIONS; i++) {
219 sect = &data_sections[i];
220
221 ASSERT(sect->sect_align == 0 || ISP2(sect->sect_align));
222 ASSERT(sect->sect_align <= sizeof (uint64_t));
223
224 len += strlen(sect->sect_name) + 1;
225 if (strcmp(sect->sect_name, ".shstrtab") == 0)
226 shstrtab = i;
227 else if (strcmp(sect->sect_name, ".symtab") == 0)
228 symtab = i;
229 else if (strcmp(sect->sect_name, ".strtab") == 0)
230 strtab = i;
231 }
232
233 strdata = kmem_zalloc(len, KM_SLEEP);
234 sect = &data_sections[shstrtab];
235 sect->sect_addr = (uintptr_t)strdata;
236 sect->sect_size = len;
237
238 len = 0;
239 for (i = 0; i < NSECTIONS; i++) {
240 sect = &data_sections[i];
241 sect->sect_str = len;
242 bcopy(sect->sect_name, strdata + len,
243 strlen(sect->sect_name) + 1);
244 len += strlen(sect->sect_name) + 1;
245
246 if (strcmp(sect->sect_name, ".SUNW_ctf") == 0)
247 sect->sect_link = symtab;
248 else if (strcmp(sect->sect_name, ".symtab") == 0)
249 sect->sect_link = strtab;
250 }
251 }
252
253 /*
254 * Given a section descriptor and module pointer, return the address of the
255 * data.
256 */
257 static uintptr_t
sect_addr(section_desc_t * sp,struct module * mp)258 sect_addr(section_desc_t *sp, struct module *mp)
259 {
260 uintptr_t addr;
261
262 switch (sp->sect_id) {
263 case SECT_TYPE_DUMMY:
264 addr = 0;
265 break;
266
267 case SECT_TYPE_SHSTRTAB:
268 addr = sp->sect_addr;
269 break;
270
271 case SECT_TYPE_STRTAB:
272 case SECT_TYPE_SYMTAB:
273 case SECT_TYPE_DATA:
274 addr = *((uintptr_t *)((char *)mp + sp->sect_addr));
275 break;
276
277 case SECT_TYPE_FILENAME:
278 addr = (uintptr_t)mp->filename;
279 break;
280
281 case SECT_TYPE_INFO:
282 addr = 1; /* This can be anything nonzero */
283 break;
284 }
285
286 return (addr);
287 }
288
289 /*
290 * Given a section descriptor and module pointer, return the size of the data.
291 */
292 static size_t
sect_size(section_desc_t * sp,struct module * mp)293 sect_size(section_desc_t *sp, struct module *mp)
294 {
295 size_t size;
296
297 switch (sp->sect_id) {
298 case SECT_TYPE_DUMMY:
299 size = 0;
300 break;
301
302 case SECT_TYPE_SHSTRTAB:
303 size = sp->sect_size;
304 break;
305
306 case SECT_TYPE_DATA:
307 size = *((size_t *)((char *)mp + sp->sect_size));
308 break;
309
310 case SECT_TYPE_SYMTAB:
311 size = mp->symhdr->sh_size;
312 break;
313
314 case SECT_TYPE_STRTAB:
315 size = mp->strhdr->sh_size;
316 break;
317
318 case SECT_TYPE_INFO:
319 size = sizeof (objfs_info_t);
320 break;
321
322 case SECT_TYPE_FILENAME:
323 if (mp->filename == NULL)
324 size = 0;
325 else
326 size = strlen(mp->filename) + 1;
327 }
328
329 return (size);
330 }
331
332 /*
333 * Given a section descriptor and module pointer, return 1 if the section has
334 * valid data and should be included, 0 otherwise.
335 */
336 static int
sect_valid(section_desc_t * sp,struct module * mp)337 sect_valid(section_desc_t *sp, struct module *mp)
338 {
339 if (sp->sect_id == SECT_TYPE_DUMMY ||
340 sect_addr(sp, mp) != 0)
341 return (1);
342
343 return (0);
344 }
345
346 /*
347 * Given a section descriptor and module pointer, return the offset into the
348 * file where the data should be placed.
349 */
350 static size_t
data_offset(section_desc_t * sp,struct module * mp)351 data_offset(section_desc_t *sp, struct module *mp)
352 {
353 int i;
354 size_t len;
355 section_desc_t *cp;
356
357 if (sp != NULL && mp != NULL && !sect_valid(sp, mp))
358 return (0);
359
360 #ifdef _LP64
361 len = sizeof (Elf64_Ehdr);
362 #else
363 len = sizeof (Elf32_Ehdr);
364 #endif
365
366 /*
367 * Do a first pass to account for all the section headers.
368 */
369 for (i = 0; i < NSECTIONS; i++) {
370 if (sect_valid(&data_sections[i], mp)) {
371 #ifdef _LP64
372 len += sizeof (Elf64_Shdr);
373 #else
374 len += sizeof (Elf32_Shdr);
375 #endif
376 }
377 }
378
379 /*
380 * Add length of each section until we find the one we're looking for.
381 */
382 for (i = 0; i < NSECTIONS; i++) {
383 cp = &data_sections[i];
384
385 /*
386 * Align the section only if it's valid and contains data. When
387 * searching for a specific section, align the section before
388 * breaking out of the loop.
389 */
390 if (sect_valid(cp, mp) && cp->sect_type != SHT_NOBITS) {
391 if (cp->sect_align > 1)
392 len = P2ROUNDUP(len, cp->sect_align);
393
394 if (sp != cp)
395 len += sect_size(cp, mp);
396 }
397
398 if (sp == cp)
399 break;
400 }
401
402 return (len);
403 }
404
405 /*
406 * Given an index into the section table and a module pointer, returns the
407 * data offset of the next section.
408 */
409 static size_t
next_offset(int idx,struct module * mp)410 next_offset(int idx, struct module *mp)
411 {
412 int i;
413
414 for (i = idx + 1; i < NSECTIONS; i++) {
415 if (sect_valid(&data_sections[i], mp))
416 return (data_offset(&data_sections[i], mp));
417 }
418
419 return (data_offset(NULL, mp));
420 }
421
422 /*
423 * Given a module pointer, return the total size needed for the file.
424 */
425 static size_t
data_size(struct module * mp)426 data_size(struct module *mp)
427 {
428 return (data_offset(NULL, mp));
429 }
430
431 /*
432 * Returns the size needed for all the headers in the file.
433 */
434 static size_t
header_size(void)435 header_size(void)
436 {
437 return (data_offset(&data_sections[0], NULL));
438 }
439
440 /* ARGSUSED */
441 vnode_t *
objfs_create_data(vnode_t * pvp)442 objfs_create_data(vnode_t *pvp)
443 {
444 objfs_odirnode_t *onode = pvp->v_data;
445 vnode_t *vp = gfs_file_create(sizeof (objfs_datanode_t), pvp,
446 objfs_ops_data);
447 objfs_datanode_t *dnode = vp->v_data;
448
449 dnode->objfs_data_gencount = onode->objfs_odir_modctl->mod_gencount;
450 dnode->objfs_data_info.objfs_info_primary =
451 onode->objfs_odir_modctl->mod_prim;
452
453 return (vp);
454 }
455
456 /* ARGSUSED */
457 static int
objfs_data_getattr(vnode_t * vp,vattr_t * vap,int flags,cred_t * cr,caller_context_t * ct)458 objfs_data_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
459 caller_context_t *ct)
460 {
461 struct module *mp;
462 timestruc_t now;
463
464 if ((mp = objfs_data_lock(vp)) == NULL)
465 return (EIO);
466
467 vap->va_type = VREG;
468 vap->va_mode = S_IRUSR | S_IRGRP | S_IROTH;
469 vap->va_nodeid = gfs_file_inode(vp);
470 vap->va_nlink = 1;
471 vap->va_size = data_size(mp);
472 gethrestime(&now);
473 vap->va_atime = vap->va_ctime = vap->va_mtime = now;
474
475 (void) objfs_common_getattr(vp, vap);
476
477 objfs_data_unlock(vp);
478
479 return (0);
480 }
481
482 /* ARGSUSED */
483 static int
objfs_data_access(vnode_t * vp,int mode,int flags,cred_t * cr,caller_context_t * ct)484 objfs_data_access(vnode_t *vp, int mode, int flags, cred_t *cr,
485 caller_context_t *ct)
486 {
487 if (mode & (VWRITE|VEXEC))
488 return (EACCES);
489
490 return (0);
491 }
492
493 /* ARGSUSED */
494 int
objfs_data_open(vnode_t ** cpp,int flag,cred_t * cr,caller_context_t * ct)495 objfs_data_open(vnode_t **cpp, int flag, cred_t *cr,
496 caller_context_t *ct)
497 {
498 if (flag & FWRITE)
499 return (EINVAL);
500
501 return (0);
502 }
503
504 /*
505 * Iterate over all symbols in the table and output each one individually,
506 * converting st_shndx to SHN_ABS for each symbol.
507 */
508 static int
read_symtab(void * addr,size_t size,off_t offset,uio_t * uio)509 read_symtab(void *addr, size_t size, off_t offset, uio_t *uio)
510 {
511 #ifdef _LP64
512 Elf64_Sym sym, *symtab;
513 #else
514 Elf32_Sym sym, *symtab;
515 #endif
516 off_t index;
517 int error;
518
519 symtab = addr;
520
521 if (offset % sizeof (sym) != 0) {
522 /*
523 * Be careful with the first symbol, as it is not
524 * symbol-aligned.
525 */
526 off_t partial = offset % sizeof (sym);
527
528 index = offset / sizeof (sym);
529
530 sym = symtab[index];
531 if (sym.st_shndx != SHN_UNDEF)
532 sym.st_shndx = SHN_ABS;
533
534 if ((error = uiomove((char *)&sym + partial,
535 sizeof (sym) - partial, UIO_READ, uio)) != 0 ||
536 uio->uio_resid <= 0)
537 return (error);
538
539 offset = (index + 1) * sizeof (sym);
540 }
541
542 ASSERT(size % sizeof (sym) == 0);
543
544 for (index = offset / sizeof (sym); index < size / sizeof (sym);
545 index++) {
546
547 sym = symtab[index];
548 if (sym.st_shndx != SHN_UNDEF)
549 sym.st_shndx = SHN_ABS;
550
551 if ((error = uiomove((char *)&sym, sizeof (sym), UIO_READ,
552 uio)) != 0 || uio->uio_resid <= 0)
553 return (error);
554 }
555
556 return (0);
557 }
558
559 /* ARGSUSED */
560 static int
objfs_data_read(vnode_t * vp,uio_t * uio,int ioflag,cred_t * cr,caller_context_t * ct)561 objfs_data_read(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cr,
562 caller_context_t *ct)
563 {
564 int error = 0;
565 objfs_datanode_t *dnode = vp->v_data;
566 struct module *mp;
567 off_t off;
568 #ifdef _LP64
569 Elf64_Shdr shdr;
570 #else
571 Elf32_Shdr shdr;
572 #endif
573 int i, j;
574 section_desc_t *sp;
575 void *addr;
576 int transidx[NSECTIONS];
577
578 if ((mp = objfs_data_lock(vp)) == NULL)
579 return (ENOENT);
580
581 if (uio->uio_resid <= 0 || uio->uio_offset >= data_size(mp))
582 goto error;
583
584 /*
585 * Construct an array to translate from a generic section header index
586 * to an index specific for this object.
587 */
588 for (i = 0, j = 0; i < NSECTIONS; i++) {
589 transidx[i] = j;
590 if (sect_valid(&data_sections[i], mp))
591 j++;
592
593 }
594
595 /*
596 * Check to see if we're in the Elf header
597 */
598 if (uio->uio_loffset < SECTION_OFFSET(0)) {
599 #ifdef _LP64
600 Elf64_Ehdr ehdr;
601 #else
602 Elf32_Ehdr ehdr;
603 #endif
604
605 bzero(&ehdr, sizeof (ehdr));
606
607 bcopy(ELFMAG, ehdr.e_ident, SELFMAG);
608 #ifdef _BIG_ENDIAN
609 ehdr.e_ident[EI_DATA] = ELFDATA2MSB;
610 #else
611 ehdr.e_ident[EI_DATA] = ELFDATA2LSB;
612 #endif
613 ehdr.e_ident[EI_VERSION] = EV_CURRENT;
614
615 #ifdef _LP64
616 ehdr.e_ident[EI_CLASS] = ELFCLASS64;
617 ehdr.e_type = ELFCLASS64;
618 ehdr.e_ehsize = sizeof (Elf64_Ehdr);
619 ehdr.e_phentsize = sizeof (Elf64_Phdr);
620 ehdr.e_shentsize = sizeof (Elf64_Shdr);
621 #else
622 ehdr.e_ident[EI_CLASS] = ELFCLASS32;
623 ehdr.e_type = ELFCLASS32;
624 ehdr.e_ehsize = sizeof (Elf32_Ehdr);
625 ehdr.e_phentsize = sizeof (Elf32_Phdr);
626 ehdr.e_shentsize = sizeof (Elf32_Shdr);
627 #endif
628
629 #ifdef __sparc
630 #ifdef __sparcv9
631 ehdr.e_machine = EM_SPARCV9;
632 #else
633 ehdr.e_machine = EM_SPARC;
634 #endif
635 #elif defined(__amd64)
636 ehdr.e_machine = EM_AMD64;
637 #else
638 ehdr.e_machine = EM_386;
639 #endif
640
641 ehdr.e_version = EV_CURRENT;
642 ehdr.e_type = ET_SUNWPSEUDO;
643 ehdr.e_shnum = 0;
644 ehdr.e_shoff = SECTION_OFFSET(0);
645
646 for (i = 0; i < NSECTIONS; i++) {
647 if (strcmp(data_sections[i].sect_name,
648 ".shstrtab") == 0)
649 ehdr.e_shstrndx = transidx[i];
650
651 if (sect_valid(&data_sections[i], mp))
652 ehdr.e_shnum++;
653 }
654
655 if ((error = uiomove((char *)&ehdr + uio->uio_loffset,
656 sizeof (ehdr) - uio->uio_loffset, UIO_READ, uio)) != 0 ||
657 uio->uio_resid <= 0)
658 goto error;
659 }
660
661 /*
662 * Go through and construct section headers for each section.
663 */
664 j = 0;
665 for (i = 0; i < NSECTIONS; i++) {
666 sp = &data_sections[i];
667
668 if (!sect_valid(sp, mp))
669 continue;
670
671 if (uio->uio_loffset < SECTION_OFFSET(j+1)) {
672 shdr.sh_link = transidx[sp->sect_link];
673 shdr.sh_entsize = sp->sect_entsize;
674 shdr.sh_info = 0;
675 shdr.sh_name = sp->sect_str;
676 shdr.sh_type = sp->sect_type;
677 shdr.sh_flags = sp->sect_flags;
678 shdr.sh_addr = sect_addr(sp, mp);
679 shdr.sh_offset = data_offset(sp, mp);
680 shdr.sh_size = sect_size(sp, mp);
681 shdr.sh_addralign = sp->sect_align;
682
683 off = uio->uio_loffset - SECTION_OFFSET(j);
684 if ((error = uiomove((char *)&shdr + off,
685 sizeof (shdr) - off, UIO_READ, uio)) != 0 ||
686 uio->uio_resid <= 0)
687 goto error;
688 }
689
690 j++;
691 }
692
693 /*
694 * Output the data for each section
695 */
696 for (i = 0; i < NSECTIONS; i++) {
697 size_t nextoff;
698 sp = &data_sections[i];
699 nextoff = next_offset(i, mp);
700 if (sect_valid(sp, mp) && sp->sect_type != SHT_NOBITS &&
701 uio->uio_loffset < nextoff) {
702
703 if (sp->sect_id == SECT_TYPE_INFO)
704 addr = &dnode->objfs_data_info;
705 else
706 addr = (void *)sect_addr(sp, mp);
707 off = uio->uio_loffset - data_offset(sp, mp);
708
709 /*
710 * The symtab requires special processing to convert
711 * the st_shndx field to SHN_ABS. Otherwise, simply
712 * copy the data in bulk.
713 */
714 if (sp->sect_id == SECT_TYPE_SYMTAB)
715 error = read_symtab(addr, sect_size(sp, mp),
716 off, uio);
717 else
718 error = uiomove((char *)addr + off,
719 sect_size(sp, mp) - off, UIO_READ, uio);
720
721 if (error != 0 || uio->uio_resid <= 0)
722 goto error;
723
724 /*
725 * If the next section needs to be aligned, pad out with
726 * zeroes.
727 */
728 if (uio->uio_loffset < nextoff) {
729 uint64_t padding = 0;
730
731 ASSERT(nextoff - uio->uio_loffset <
732 sizeof (uint64_t));
733
734 if ((error = uiomove(&padding,
735 nextoff - uio->uio_loffset, UIO_READ,
736 uio)) != 0 || uio->uio_resid <= 0)
737 goto error;
738
739 }
740 }
741 }
742
743 error:
744 objfs_data_unlock(vp);
745
746 return (error);
747 }
748
749 /* ARGSUSED */
750 static int
objfs_data_seek(vnode_t * vp,offset_t off,offset_t * offp,caller_context_t * ct)751 objfs_data_seek(vnode_t *vp, offset_t off, offset_t *offp,
752 caller_context_t *ct)
753 {
754 return (0);
755 }
756
757 const fs_operation_def_t objfs_tops_data[] = {
758 { VOPNAME_OPEN, { .vop_open = objfs_data_open } },
759 { VOPNAME_CLOSE, { .vop_close = objfs_common_close } },
760 { VOPNAME_IOCTL, { .error = fs_inval } },
761 { VOPNAME_GETATTR, { .vop_getattr = objfs_data_getattr } },
762 { VOPNAME_ACCESS, { .vop_access = objfs_data_access } },
763 { VOPNAME_INACTIVE, { .vop_inactive = gfs_vop_inactive } },
764 { VOPNAME_READ, { .vop_read = objfs_data_read } },
765 { VOPNAME_SEEK, { .vop_seek = objfs_data_seek } },
766 { VOPNAME_MAP, { .vop_map = gfs_vop_map } },
767 { NULL }
768 };
769