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, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 /*
30 * Source file for the cfsd_kmod class.
31 */
32
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <stddef.h>
36 #include <string.h>
37 #include <errno.h>
38 #include <unistd.h>
39 #include <fcntl.h>
40 #include <sys/param.h>
41 #include <sys/types.h>
42 #include <sys/fcntl.h>
43 #include <sys/cred.h>
44 #include <sys/vnode.h>
45 #include <sys/vfs.h>
46 #include <sys/fs/cachefs_fs.h>
47 #include <sys/fs/cachefs_dlog.h>
48 #include <sys/fs/cachefs_ioctl.h>
49 #include <mdbug/mdbug.h>
50 #include "cfsd.h"
51 #include "cfsd_kmod.h"
52
53 /*
54 * copy_cred (copy dl_cred_t followed by a list of gid_t)
55 */
56
57 static void
58 copy_cred(dl_cred_t *dst, const dl_cred_t *src)
59 {
60 int n = src->cr_ngroups;
61
62 if (n > NGROUPS_MAX_DEFAULT)
63 n = NGROUPS_MAX_DEFAULT;
64
65 (void) memcpy(dst, src, sizeof (*dst) + (n - 1) * sizeof (gid_t));
66 dst->cr_ngroups = n;
67 }
68
69 /*
70 * ------------------------------------------------------------
71 * cfsd_kmod_create
72 *
73 * Description:
74 * Arguments:
75 * Returns:
76 * Preconditions:
77 */
78
79 cfsd_kmod_object_t *
80 cfsd_kmod_create(void)
81 {
82 cfsd_kmod_object_t *kmod_object_p;
83
84 dbug_enter("cfsd_kmod_create");
85 kmod_object_p = cfsd_calloc(sizeof (cfsd_kmod_object_t));
86
87 kmod_object_p->i_fd = -1;
88
89 dbug_leave("cfsd_kmod_create");
90 return (kmod_object_p);
91 }
92
93 /*
94 * ------------------------------------------------------------
95 * cfsd_kmod_destory
96 *
97 * Description:
98 * Arguments:
99 * Returns:
100 * Preconditions:
101 */
102
103
104 void
105 cfsd_kmod_destroy(cfsd_kmod_object_t *kmod_object_p)
106 {
107 dbug_enter("cfsd_kmod_destroy");
108 dbug_precond(kmod_object_p);
109
110 /* clean up old stuff */
111 kmod_shutdown(kmod_object_p);
112
113 cfsd_free(kmod_object_p);
114 dbug_leave("cfsd_kmod_destroy");
115 }
116
117 /*
118 * ------------------------------------------------------------
119 * kmod_setup
120 *
121 * Description:
122 * Arguments:
123 * path
124 * Returns:
125 * Returns ...
126 * Preconditions:
127 * precond(path)
128 */
129 int
130 kmod_setup(cfsd_kmod_object_t *kmod_object_p, const char *path)
131 {
132 int xx;
133 int error;
134
135 dbug_enter("kmod_setup");
136 dbug_precond(kmod_object_p);
137 dbug_precond(path);
138
139 /* clean up old stuff */
140 kmod_shutdown(kmod_object_p);
141
142 /* try to open the file */
143 dbug_assert(kmod_object_p->i_fd == -1);
144 kmod_object_p->i_fd = open(path, O_RDONLY);
145
146 /* return result */
147 if (kmod_object_p->i_fd == -1) {
148 xx = errno;
149 dbug_print(("err", "open of %s failed %d", path, xx));
150 } else {
151 xx = 0;
152 strlcpy(kmod_object_p->i_path, path,
153 sizeof (kmod_object_p->i_path));
154 dbug_print(("info", "opened %s on fd %d", path,
155 kmod_object_p->i_fd));
156
157 /* tell the cachefs kmod we are here */
158 xx = kmod_doioctl(kmod_object_p, CFSDCMD_DAEMONID,
159 NULL, 0, NULL, 0);
160 if (xx) {
161 error = errno;
162 dbug_print(("ioctl", "daemonid error %d", error));
163 }
164 }
165
166 dbug_leave("kmod_setup");
167 return (xx);
168 }
169
170 /*
171 * kmod_shutdown
172 *
173 * Description:
174 * Arguments:
175 * Returns:
176 * Preconditions:
177 */
178 void
179 kmod_shutdown(cfsd_kmod_object_t *kmod_object_p)
180 {
181 dbug_enter("kmod_shutdown");
182 dbug_precond(kmod_object_p);
183
184 /* close down the old fd if necessary */
185 if (kmod_object_p->i_fd >= 0) {
186 if (close(kmod_object_p->i_fd))
187 dbug_print(("err", "cannot close kmod fd, %d", errno));
188 }
189 kmod_object_p->i_fd = -1;
190 dbug_leave("kmod_shutdown");
191 }
192
193 /*
194 * ------------------------------------------------------------
195 * kmod_xwait
196 *
197 * Description:
198 * Arguments:
199 * Returns:
200 * Returns ...
201 * Preconditions:
202 */
203 int
204 kmod_xwait(cfsd_kmod_object_t *kmod_object_p)
205 {
206 int xx;
207 int error = 0;
208
209 dbug_enter("kmod_xwait");
210 dbug_precond(kmod_object_p);
211
212 xx = kmod_doioctl(kmod_object_p, CFSDCMD_XWAIT, NULL, 0, NULL, 0);
213 if (xx)
214 error = errno;
215 dbug_print(("ioctl", "returns %d, error %d", xx, error));
216 dbug_leave("kmod_xwait");
217 return (error);
218 }
219
220 /*
221 * ------------------------------------------------------------
222 * kmod_stateget
223 *
224 * Description:
225 * Arguments:
226 * Returns:
227 * Returns ...
228 * Preconditions:
229 */
230 int
231 kmod_stateget(cfsd_kmod_object_t *kmod_object_p)
232 {
233 int state;
234 int xx;
235
236 dbug_enter("kmod_stateget");
237 dbug_precond(kmod_object_p);
238
239 xx = kmod_doioctl(kmod_object_p, CFSDCMD_STATEGET, NULL, 0, &state,
240 sizeof (state));
241 dbug_print(("ioctl", "returns %d, state %d", xx, state));
242 if (xx == -1) {
243 /* XXX do what? */
244 dbug_assert(0);
245 }
246 dbug_leave("kmod_stateget");
247 return (state);
248 }
249
250 /*
251 * ------------------------------------------------------------
252 * kmod_stateset
253 *
254 * Description:
255 * Arguments:
256 * state
257 * Returns:
258 * Returns ...
259 * Preconditions:
260 */
261 int
262 kmod_stateset(cfsd_kmod_object_t *kmod_object_p, int state)
263 {
264 int xx;
265 int error = 0;
266
267 dbug_enter("kmod_stateset");
268 dbug_precond(kmod_object_p);
269
270 xx = kmod_doioctl(kmod_object_p, CFSDCMD_STATESET, &state,
271 sizeof (state), NULL, 0);
272 if (xx)
273 error = errno;
274 dbug_print(("ioctl", "returns %d, state set to %d", xx, state));
275 dbug_leave("kmod_stateset");
276 return (error);
277 }
278
279 /*
280 * ------------------------------------------------------------
281 * kmod_exists
282 *
283 * Description:
284 * Arguments:
285 * cidp
286 * Returns:
287 * Returns ...
288 * Preconditions:
289 * precond(cidp)
290 */
291 int
292 kmod_exists(cfsd_kmod_object_t *kmod_object_p, cfs_cid_t *cidp)
293 {
294 int xx;
295 int error = 0;
296
297 dbug_enter("kmod_exists");
298 dbug_precond(kmod_object_p);
299 dbug_precond(cidp);
300
301 xx = kmod_doioctl(kmod_object_p, CFSDCMD_EXISTS, cidp,
302 sizeof (cfs_cid_t), NULL, 0);
303 if (xx)
304 error = errno;
305 dbug_print(("ioctl", "returns %d, error %d", xx, error));
306 dbug_print(("ioctl", " cid %08x", cidp->cid_fileno));
307 dbug_leave("kmod_exists");
308 return (error);
309 }
310
311 /*
312 * ------------------------------------------------------------
313 * kmod_lostfound
314 *
315 * Description:
316 * Arguments:
317 * cidp
318 * Returns:
319 * Returns ...
320 * Preconditions:
321 * precond(cidp)
322 */
323 int
324 kmod_lostfound(cfsd_kmod_object_t *kmod_object_p, cfs_cid_t *cidp,
325 const char *namep, char *newnamep)
326 {
327 cachefsio_lostfound_arg_t info;
328 cachefsio_lostfound_return_t ret;
329 int error = 0;
330 int xx;
331
332 dbug_enter("kmod_lostfound");
333 dbug_precond(kmod_object_p);
334 dbug_precond(cidp);
335 dbug_precond(namep);
336 dbug_precond(newnamep);
337 dbug_precond(strlen(namep) < (size_t)MAXNAMELEN);
338
339 info.lf_cid = *cidp;
340 strlcpy(info.lf_name, namep, sizeof (info.lf_name));
341
342 xx = kmod_doioctl(kmod_object_p, CFSDCMD_LOSTFOUND, &info,
343 sizeof (info), &ret, sizeof (ret));
344 if (xx)
345 error = errno;
346 dbug_print(("ioctl", "returns %d, error %d", xx, error));
347 dbug_print(("ioctl", " cid %08x", cidp->cid_fileno));
348 dbug_print(("ioctl", " suggested name '%s'", namep));
349 if (xx == 0) {
350 dbug_print(("ioctl", " new name '%s'", ret.lf_name));
351 dbug_assert(strlen(ret.lf_name) < (size_t)MAXNAMELEN);
352 if (newnamep)
353 strlcpy(newnamep, ret.lf_name, MAXNAMELEN);
354 }
355 dbug_leave("kmod_lostfound");
356 return (error);
357 }
358
359 #if 0
360 /*
361 * ------------------------------------------------------------
362 * kmod_lostfoundall
363 *
364 * Description:
365 * Arguments:
366 * Returns:
367 * Returns ...
368 * Preconditions:
369 */
370 int
371 kmod_lostfoundall(cfsd_kmod_object_t *kmod_object_p)
372 {
373 int error = 0;
374 int xx = -1;
375
376 dbug_enter("kmod_lostfoundall");
377 dbug_precond(kmod_object_p);
378
379 /* xx = ioctl(kmod_object_p->i_fd, CACHEFSIO_LOSTFOUNDALL, 0); */
380 if (xx)
381 error = errno;
382 dbug_print(("ioctl", "returns %d, error %d", xx, error));
383 dbug_leave("kmod_lostfoundall");
384 return (error);
385 }
386 /*
387 * kmod_rofs
388 *
389 * Description:
390 * Arguments:
391 * Returns:
392 * Returns ...
393 * Preconditions:
394 */
395 int
396 kmod_rofs(cfsd_kmod_object_t *kmod_object_p)
397 {
398 int error = 0;
399 int xx = -1;
400
401 dbug_enter("kmod_rofs");
402 dbug_precond(kmod_object_p);
403
404 /* xx = ioctl(kmod_object_p->i_fd, CACHEFSIO_ROFS, 0); */
405 if (xx)
406 error = errno;
407 dbug_print(("ioctl", "returns %d, error %d", xx, error));
408 dbug_leave("kmod_rofs");
409 return (error);
410 }
411 #endif
412
413 /*
414 * kmod_rootfid
415 *
416 * Description:
417 * Fills in fidp with the fid of the root of the file system.
418 * Arguments:
419 * fidp
420 * Returns:
421 * Returns 0 for success, errno value for an error
422 * Preconditions:
423 * precond(fidp)
424 */
425 int
426 kmod_rootfid(cfsd_kmod_object_t *kmod_object_p, cfs_fid_t *fidp)
427 {
428 int error = 0;
429 int xx;
430
431 dbug_enter("kmod_rootfid");
432 dbug_precond(kmod_object_p);
433 dbug_precond(fidp);
434
435 xx = kmod_doioctl(kmod_object_p, CFSDCMD_ROOTFID, NULL, 0, fidp,
436 sizeof (*fidp));
437 if (xx)
438 error = errno;
439 dbug_print(("ioctl", "returns %d, error %d", xx, error));
440 dbug_leave("kmod_rootfid");
441 return (error);
442 }
443
444
445 /*
446 * kmod_getstats
447 *
448 * Description:
449 * Arguments:
450 * gsp
451 * Returns:
452 * Returns ...
453 * Preconditions:
454 * precond(gsp)
455 */
456 int
457 kmod_getstats(cfsd_kmod_object_t *kmod_object_p, cachefsio_getstats_t *gsp)
458 {
459 int error = 0;
460 int xx;
461
462 dbug_enter("kmod_getstats");
463 dbug_precond(kmod_object_p);
464
465 dbug_precond(gsp);
466
467 xx = kmod_doioctl(kmod_object_p, CFSDCMD_GETSTATS, NULL, 0, gsp,
468 sizeof (*gsp));
469 if (xx)
470 error = errno;
471 dbug_print(("ioctl", "returns %d, error %d", xx, error));
472 dbug_print(("ioctl", "total blocks %d", gsp->gs_total));
473 dbug_print(("ioctl", "gc blocks %d", gsp->gs_gc));
474 dbug_print(("ioctl", "active blocks %d", gsp->gs_active));
475 dbug_print(("ioctl", "packed blocks %d", gsp->gs_packed));
476 dbug_print(("ioctl", "free blocks %d", gsp->gs_free));
477 dbug_print(("ioctl", "gctime %x", gsp->gs_gctime));
478 dbug_leave("kmod_getstats");
479 return (error);
480 }
481
482 /*
483 * ------------------------------------------------------------
484 * kmod_getinfo
485 *
486 * Description:
487 * Arguments:
488 * filep
489 * Returns:
490 * Returns ...
491 * Preconditions:
492 * precond(filep)
493 * precond(infop)
494 */
495 int
496 kmod_getinfo(cfsd_kmod_object_t *kmod_object_p, cfs_cid_t *filep,
497 cachefsio_getinfo_t *infop)
498 {
499 int error = 0;
500 int xx;
501
502 dbug_enter("kmod_getinfo");
503 dbug_precond(kmod_object_p);
504
505 dbug_precond(filep);
506 dbug_precond(infop);
507
508 xx = kmod_doioctl(kmod_object_p, CFSDCMD_GETINFO, filep,
509 sizeof (*filep), infop, sizeof (*infop));
510 if (xx)
511 error = errno;
512
513 dbug_print(("ioctl", "returns %d, error %d", xx, error));
514 dbug_print(("ioctl", " file cid %08x", filep->cid_fileno));
515 if (xx == 0) {
516 dbug_print(("ioctl", " modified %d seq %d",
517 infop->gi_modified, infop->gi_seq));
518 dbug_print(("ioctl", " name \"%s\"", infop->gi_name));
519 dbug_print(("ioctl", " parent cid %08x",
520 infop->gi_pcid.cid_fileno));
521 infop->gi_attr.va_mask = AT_ALL;
522 kmod_print_attr(&infop->gi_attr);
523 }
524 dbug_leave("kmod_getinfo");
525 return (error);
526 }
527
528 /*
529 * ------------------------------------------------------------
530 * kmod_cidtofid
531 *
532 * Description:
533 * Arguments:
534 * cidp
535 * fidp
536 * Returns:
537 * Returns ...
538 * Preconditions:
539 * precond(cidp)
540 * precond(fidp)
541 */
542 int
543 kmod_cidtofid(cfsd_kmod_object_t *kmod_object_p, cfs_cid_t *cidp,
544 cfs_fid_t *fidp)
545 {
546 int error = 0;
547 int xx;
548
549 dbug_enter("kmod_cidtofid");
550 dbug_precond(kmod_object_p);
551
552 dbug_precond(cidp);
553 dbug_precond(fidp);
554
555 xx = kmod_doioctl(kmod_object_p, CFSDCMD_CIDTOFID, cidp, sizeof (*cidp),
556 fidp, sizeof (*fidp));
557 if (xx)
558 error = errno;
559
560 dbug_print(("ioctl", "returns %d, error %d", xx, error));
561 dbug_print(("ioctl", " cid %08x", cidp->cid_fileno));
562 if (xx == 0) {
563 kmod_format_fid(kmod_object_p, fidp);
564 dbug_print(("ioctl", " fid \"%s\"", kmod_object_p->i_fidbuf));
565 }
566 dbug_leave("kmod_cidtofid");
567 return (error);
568 }
569
570 /*
571 * ------------------------------------------------------------
572 * kmod_getattrfid
573 *
574 * Description:
575 * Arguments:
576 * fidp
577 * credp
578 * vattrp
579 * Returns:
580 * Returns ...
581 * Preconditions:
582 * precond(fidp)
583 * precond(credp)
584 * precond(vattrp)
585 */
586 int
587 kmod_getattrfid(cfsd_kmod_object_t *kmod_object_p, cfs_fid_t *fidp,
588 dl_cred_t *credp, vattr_t *vattrp)
589 {
590 int error = 0;
591 int xx;
592 cachefsio_getattrfid_t info;
593
594 dbug_enter("kmod_getattrfid");
595 dbug_precond(kmod_object_p);
596
597 dbug_precond(fidp);
598 dbug_precond(credp);
599 dbug_precond(vattrp);
600
601 info.cg_backfid = *fidp;
602
603 copy_cred(&info.cg_cred, credp);
604
605 xx = kmod_doioctl(kmod_object_p, CFSDCMD_GETATTRFID, &info,
606 sizeof (info), vattrp, sizeof (*vattrp));
607 if (xx)
608 error = errno;
609
610 dbug_print(("ioctl", "returns %d, error %d", xx, error));
611 kmod_format_fid(kmod_object_p, fidp);
612 dbug_print(("ioctl", " fid \"%s\"", kmod_object_p->i_fidbuf));
613 kmod_print_cred(credp);
614 if (xx == 0) {
615 vattrp->va_mask = AT_ALL;
616 kmod_print_attr(vattrp);
617 }
618 dbug_leave("kmod_getattrfid");
619 return (error);
620 }
621
622 /*
623 * ------------------------------------------------------------
624 * kmod_getattrname
625 *
626 * Description:
627 * Arguments:
628 * dirp
629 * name
630 * credp
631 * vattrp
632 * filep
633 * Returns:
634 * Returns ...
635 * Preconditions:
636 * precond(dirp)
637 * precond(name)
638 * precond(credp)
639 */
640 int
641 kmod_getattrname(cfsd_kmod_object_t *kmod_object_p, cfs_fid_t *dirp,
642 const char *name, dl_cred_t *credp, vattr_t *vattrp, cfs_fid_t *filep)
643 {
644 cachefsio_getattrname_arg_t info;
645 cachefsio_getattrname_return_t ret;
646 int error = 0;
647 int xx;
648
649 dbug_enter("kmod_getattrname");
650 dbug_precond(kmod_object_p);
651
652 dbug_precond(dirp);
653 dbug_precond(name);
654 dbug_precond(credp);
655
656 info.cg_dir = *dirp;
657 dbug_assert(strlen(name) < (size_t)MAXNAMELEN);
658 strlcpy(info.cg_name, name, sizeof (info.cg_name));
659 copy_cred(&info.cg_cred, credp);
660
661 xx = kmod_doioctl(kmod_object_p, CFSDCMD_GETATTRNAME, &info,
662 sizeof (info), &ret, sizeof (ret));
663 if (xx)
664 error = errno;
665
666 dbug_print(("ioctl", "returns %d, error %d", xx, error));
667 kmod_format_fid(kmod_object_p, dirp);
668 dbug_print(("ioctl", " dir fid \"%s\"", kmod_object_p->i_fidbuf));
669 dbug_print(("ioctl", " name '%s'", info.cg_name));
670 kmod_print_cred(credp);
671 if (xx == 0) {
672 ret.cg_attr.va_mask = AT_ALL;
673 kmod_print_attr(&ret.cg_attr);
674 kmod_format_fid(kmod_object_p, &ret.cg_fid);
675 dbug_print(("ioctl", " file fid \"%s\"",
676 kmod_object_p->i_fidbuf));
677 if (vattrp)
678 *vattrp = ret.cg_attr;
679 if (filep)
680 *filep = ret.cg_fid;
681 }
682 dbug_leave("kmod_getattrname");
683 return (error);
684 }
685
686 /*
687 * ------------------------------------------------------------
688 * kmod_create
689 *
690 * Description:
691 * Arguments:
692 * dirp
693 * namep
694 * vattrp
695 * exclusive
696 * mode
697 * credp
698 * newfidp
699 * mtimep
700 * ctimep
701 * Returns:
702 * Returns ...
703 * Preconditions:
704 * precond(dirp)
705 * precond(namep)
706 * precond(vattrp)
707 * precond(credp)
708 */
709 int
710 kmod_create(cfsd_kmod_object_t *kmod_object_p,
711 cfs_fid_t *dirp,
712 const char *namep,
713 const cfs_cid_t *cidp,
714 vattr_t *vattrp,
715 int exclusive,
716 int mode,
717 dl_cred_t *credp,
718 cfs_fid_t *newfidp,
719 cfs_timestruc_t *ctimep,
720 cfs_timestruc_t *mtimep)
721 {
722 cachefsio_create_arg_t info;
723 cachefsio_create_return_t ret;
724 int error = 0;
725 int xx;
726
727 dbug_enter("kmod_create");
728 dbug_precond(kmod_object_p);
729
730 dbug_precond(dirp);
731 dbug_precond(namep);
732 dbug_precond(vattrp);
733 dbug_precond(credp);
734
735 info.cr_backfid = *dirp;
736 dbug_assert(strlen(namep) < (size_t)MAXNAMELEN);
737 strlcpy(info.cr_name, namep, sizeof (info.cr_name));
738 if (cidp) {
739 info.cr_cid = *cidp;
740 } else {
741 info.cr_cid.cid_fileno = 0;
742 info.cr_cid.cid_flags = 0;
743 }
744 info.cr_va = *vattrp;
745 info.cr_exclusive = exclusive;
746 info.cr_mode = mode;
747 copy_cred(&info.cr_cred, credp);
748
749 xx = kmod_doioctl(kmod_object_p, CFSDCMD_CREATE, &info, sizeof (info),
750 &ret, sizeof (ret));
751 if (xx)
752 error = errno;
753
754 dbug_print(("ioctl", "returns %d, error %d", xx, error));
755 kmod_format_fid(kmod_object_p, dirp);
756 dbug_print(("ioctl", " dir fid \"%s\"", kmod_object_p->i_fidbuf));
757 dbug_print(("ioctl", " name '%s', exclusive %d, mode 0%o",
758 namep, exclusive, mode));
759 kmod_print_attr(vattrp);
760 kmod_print_cred(credp);
761 if (xx == 0) {
762 if (newfidp)
763 *newfidp = ret.cr_newfid;
764 if (ctimep)
765 *ctimep = ret.cr_ctime;
766 if (mtimep)
767 *mtimep = ret.cr_mtime;
768 kmod_format_fid(kmod_object_p, &ret.cr_newfid);
769 dbug_print(("ioctl", " created file fid \"%s\"",
770 kmod_object_p->i_fidbuf));
771 dbug_print(("ioctl", " ctime %x %x",
772 ret.cr_ctime.tv_sec, ret.cr_ctime.tv_nsec));
773 dbug_print(("ioctl", " mtime %x %x",
774 ret.cr_mtime.tv_sec, ret.cr_mtime.tv_nsec));
775 }
776 dbug_leave("kmod_create");
777 return (error);
778 }
779
780 /*
781 * ------------------------------------------------------------
782 * kmod_pushback
783 *
784 * Description:
785 * Arguments:
786 * filep
787 * fidp
788 * credp
789 * Returns:
790 * Returns ...
791 * Preconditions:
792 * precond(filep)
793 * precond(fidp)
794 * precond(credp)
795 */
796 int
797 kmod_pushback(cfsd_kmod_object_t *kmod_object_p,
798 cfs_cid_t *filep,
799 cfs_fid_t *fidp,
800 dl_cred_t *credp,
801 cfs_timestruc_t *ctimep,
802 cfs_timestruc_t *mtimep,
803 int update)
804 {
805 cachefsio_pushback_arg_t info;
806 cachefsio_pushback_return_t ret;
807 int error = 0;
808 int xx;
809
810 dbug_enter("kmod_pushback");
811 dbug_precond(kmod_object_p);
812
813 dbug_precond(filep);
814 dbug_precond(fidp);
815 dbug_precond(credp);
816
817 /* note: update is no longer used */
818
819 info.pb_cid = *filep;
820 info.pb_fid = *fidp;
821 copy_cred(&info.pb_cred, credp);
822
823 xx = kmod_doioctl(kmod_object_p, CFSDCMD_PUSHBACK, &info, sizeof (info),
824 &ret, sizeof (ret));
825 if (xx)
826 error = errno;
827
828 dbug_print(("ioctl", "returns %d, error %d", xx, error));
829 dbug_print(("ioctl", " cid %08x", filep->cid_fileno));
830 kmod_format_fid(kmod_object_p, fidp);
831 dbug_print(("ioctl", " fid \"%s\"", kmod_object_p->i_fidbuf));
832 kmod_print_cred(credp);
833 if (xx == 0) {
834 if (ctimep)
835 *ctimep = ret.pb_ctime;
836 if (mtimep)
837 *mtimep = ret.pb_mtime;
838 dbug_print(("ioctl", " ctime %x %x",
839 ret.pb_ctime.tv_sec, ret.pb_ctime.tv_nsec));
840 dbug_print(("ioctl", " mtime %x %x",
841 ret.pb_mtime.tv_sec, ret.pb_mtime.tv_nsec));
842 }
843 dbug_leave("kmod_pushback");
844 return (error);
845 }
846
847
848 /*
849 * ------------------------------------------------------------
850 * kmod_rename
851 *
852 * Description:
853 * Arguments:
854 * olddir
855 * oldname
856 * newdir
857 * newname
858 * credp
859 * Returns:
860 * Returns ...
861 * Preconditions:
862 * precond(olddir)
863 * precond(oldname)
864 * precond(newdir)
865 * precond(newname)
866 * precond(credp)
867 */
868 int
869 kmod_rename(cfsd_kmod_object_t *kmod_object_p,
870 cfs_fid_t *olddir,
871 const char *oldname,
872 cfs_fid_t *newdir,
873 const char *newname,
874 const cfs_cid_t *cidp,
875 dl_cred_t *credp,
876 cfs_timestruc_t *ctimep,
877 cfs_timestruc_t *delctimep,
878 const cfs_cid_t *delcidp)
879 {
880 cachefsio_rename_arg_t info;
881 cachefsio_rename_return_t ret;
882 int error = 0;
883 int xx;
884
885 dbug_enter("kmod_rename");
886 dbug_precond(kmod_object_p);
887
888 dbug_precond(olddir);
889 dbug_precond(oldname);
890 dbug_precond(newdir);
891 dbug_precond(newname);
892 dbug_precond(credp);
893 dbug_precond(ctimep);
894
895 info.rn_olddir = *olddir;
896 dbug_assert(strlen(oldname) < (size_t)MAXNAMELEN);
897 strlcpy(info.rn_oldname, oldname, sizeof (info.rn_oldname));
898 info.rn_newdir = *newdir;
899 dbug_assert(strlen(newname) < (size_t)MAXNAMELEN);
900 strlcpy(info.rn_newname, newname, sizeof (info.rn_newname));
901 info.rn_cid = *cidp;
902 copy_cred(&info.rn_cred, credp);
903 info.rn_del_getctime = delctimep ? 1 : 0;
904 info.rn_del_cid = *delcidp;
905
906 xx = kmod_doioctl(kmod_object_p, CFSDCMD_RENAME, &info, sizeof (info),
907 &ret, sizeof (ret));
908 if (xx)
909 error = errno;
910
911 dbug_print(("ioctl", "returns %d, error %d", xx, error));
912 kmod_format_fid(kmod_object_p, olddir);
913 dbug_print(("ioctl", " old dir fid \"%s\"", kmod_object_p->i_fidbuf));
914 kmod_format_fid(kmod_object_p, newdir);
915 dbug_print(("ioctl", " new dir fid \"%s\"", kmod_object_p->i_fidbuf));
916 dbug_print(("ioctl", " old name '%s' new name '%s'",
917 oldname, newname));
918 kmod_print_cred(credp);
919 if (xx == 0) {
920 *ctimep = ret.rn_ctime;
921 dbug_print(("ioctl", " ctime %x %x",
922 ctimep->tv_sec, ctimep->tv_nsec));
923 if (delctimep) {
924 *delctimep = ret.rn_del_ctime;
925 dbug_print(("ioctl", " del ctime %x %x",
926 delctimep->tv_sec, delctimep->tv_nsec));
927 }
928 }
929 dbug_leave("kmod_rename");
930 return (error);
931 }
932
933 /*
934 * ------------------------------------------------------------
935 * kmod_setattr
936 *
937 * Description:
938 * Arguments:
939 * fidp
940 * vattrp
941 * flags
942 * credp
943 * Returns:
944 * Returns ...
945 * Preconditions:
946 * precond(fidp)
947 * precond(vattrp)
948 * precond(credp)
949 */
950 int
951 kmod_setattr(cfsd_kmod_object_t *kmod_object_p,
952 cfs_fid_t *fidp,
953 const cfs_cid_t *cidp,
954 vattr_t *vattrp,
955 int flags,
956 dl_cred_t *credp,
957 cfs_timestruc_t *ctimep,
958 cfs_timestruc_t *mtimep)
959 {
960 cachefsio_setattr_arg_t info;
961 cachefsio_setattr_return_t ret;
962 int error = 0;
963 int xx;
964
965 dbug_enter("kmod_setattr");
966 dbug_precond(kmod_object_p);
967
968 dbug_precond(fidp);
969 dbug_precond(cidp);
970 dbug_precond(vattrp);
971 dbug_precond(credp);
972 dbug_precond(ctimep);
973 dbug_precond(mtimep);
974
975 info.sa_backfid = *fidp;
976 info.sa_cid = *cidp;
977 info.sa_vattr = *vattrp;
978 info.sa_flags = flags;
979 copy_cred(&info.sa_cred, credp);
980
981 xx = kmod_doioctl(kmod_object_p, CFSDCMD_SETATTR, &info, sizeof (info),
982 &ret, sizeof (ret));
983 if (xx)
984 error = errno;
985
986 dbug_print(("ioctl", "returns %d, error %d", xx, error));
987 dbug_print(("ioctl", " flags 0x%x", flags));
988 kmod_format_fid(kmod_object_p, fidp);
989 dbug_print(("ioctl", " fid \"%s\"", kmod_object_p->i_fidbuf));
990 kmod_print_attr(vattrp);
991 kmod_print_cred(credp);
992 if (xx == 0) {
993 *ctimep = ret.sa_ctime;
994 *mtimep = ret.sa_mtime;
995 dbug_print(("ioctl", " ctime %x %x", ctimep->tv_sec,
996 ctimep->tv_nsec));
997 dbug_print(("ioctl", " mtime %x %x", mtimep->tv_sec,
998 mtimep->tv_nsec));
999 }
1000 dbug_leave("kmod_setattr");
1001 return (error);
1002 }
1003
1004 /*
1005 * ------------------------------------------------------------
1006 * kmod_setsecattr
1007 *
1008 * Description:
1009 * Arguments:
1010 * fidp
1011 * aclcnt
1012 * dfaclcnt
1013 * acl
1014 * flags
1015 * credp
1016 * Returns:
1017 * Returns ...
1018 * Preconditions:
1019 * precond(fidp)
1020 * precond(acl)
1021 * precond(credp)
1022 * precond(aclcnt + dfaclcnt <= MAX_ACL_ENTRIES)
1023 */
1024 int
1025 kmod_setsecattr(cfsd_kmod_object_t *kmod_object_p,
1026 cfs_fid_t *fidp,
1027 const cfs_cid_t *cidp,
1028 ulong_t mask,
1029 int aclcnt,
1030 int dfaclcnt,
1031 const aclent_t *acl,
1032 dl_cred_t *credp,
1033 cfs_timestruc_t *ctimep,
1034 cfs_timestruc_t *mtimep)
1035 {
1036 cachefsio_setsecattr_arg_t info;
1037 cachefsio_setsecattr_return_t ret;
1038 int error = 0;
1039 int xx;
1040
1041 dbug_enter("kmod_setsecattr");
1042 dbug_precond(kmod_object_p);
1043
1044 dbug_precond(fidp);
1045 dbug_precond(cidp);
1046 dbug_precond(acl);
1047 dbug_precond(credp);
1048 dbug_precond(ctimep);
1049 dbug_precond(mtimep);
1050 dbug_precond(aclcnt + dfaclcnt <= MAX_ACL_ENTRIES);
1051
1052 info.sc_backfid = *fidp;
1053 info.sc_cid = *cidp;
1054 info.sc_mask = mask;
1055 info.sc_aclcnt = aclcnt;
1056 info.sc_dfaclcnt = dfaclcnt;
1057 memcpy(&info.sc_acl, acl, (aclcnt + dfaclcnt) * sizeof (aclent_t));
1058 copy_cred(&info.sc_cred, credp);
1059
1060 xx = kmod_doioctl(kmod_object_p, CFSDCMD_SETSECATTR, &info,
1061 sizeof (info), &ret, sizeof (ret));
1062 if (xx)
1063 error = errno;
1064
1065 dbug_print(("ioctl", "returns %d, error %d", xx, error));
1066 kmod_format_fid(kmod_object_p, fidp);
1067 dbug_print(("ioctl", " fid \"%s\"", kmod_object_p->i_fidbuf));
1068 dbug_print(("ioctl", " aclcnt %d dfaclcnt %d", aclcnt, dfaclcnt));
1069 kmod_print_cred(credp);
1070 if (xx == 0) {
1071 *ctimep = ret.sc_ctime;
1072 *mtimep = ret.sc_mtime;
1073 dbug_print(("ioctl", " ctime %x %x", ctimep->tv_sec,
1074 ctimep->tv_nsec));
1075 dbug_print(("ioctl", " mtime %x %x", mtimep->tv_sec,
1076 mtimep->tv_nsec));
1077 }
1078 dbug_leave("kmod_setsecattr");
1079 return (error);
1080 }
1081
1082 /*
1083 * ------------------------------------------------------------
1084 * kmod_remove
1085 *
1086 * Description:
1087 * Arguments:
1088 * fidp
1089 * namep
1090 * credp
1091 * ctimep
1092 * Returns:
1093 * Returns ...
1094 * Preconditions:
1095 * precond(fidp)
1096 * precond(namep)
1097 * precond(credp)
1098 */
1099 int
1100 kmod_remove(cfsd_kmod_object_t *kmod_object_p,
1101 const cfs_fid_t *fidp,
1102 const cfs_cid_t *cidp,
1103 const char *namep,
1104 const dl_cred_t *credp,
1105 cfs_timestruc_t *ctimep)
1106 {
1107 cachefsio_remove_t info;
1108 int len;
1109 int error = 0;
1110 int xx;
1111
1112 dbug_enter("kmod_remove");
1113 dbug_precond(kmod_object_p);
1114
1115 dbug_precond(fidp);
1116 dbug_precond(cidp);
1117 dbug_precond(namep);
1118 dbug_precond(credp);
1119
1120 info.rm_fid = *fidp;
1121 info.rm_cid = *cidp;
1122 dbug_assert(strlen(namep) < (size_t)MAXNAMELEN);
1123 strlcpy(info.rm_name, namep, sizeof (info.rm_name));
1124 copy_cred(&info.rm_cred, credp);
1125 info.rm_getctime = ctimep ? 1 : 0;
1126
1127 if (ctimep)
1128 len = sizeof (*ctimep);
1129 else
1130 len = 0;
1131
1132 xx = kmod_doioctl(kmod_object_p, CFSDCMD_REMOVE, &info, sizeof (info),
1133 ctimep, len);
1134 if (xx)
1135 error = errno;
1136
1137 dbug_print(("ioctl", "returns %d, error %d", xx, error));
1138 kmod_format_fid(kmod_object_p, fidp);
1139 dbug_print(("ioctl", " fid '%s'", kmod_object_p->i_fidbuf));
1140 dbug_print(("ioctl", " name '%s'", namep));
1141 kmod_print_cred(credp);
1142 if ((xx == 0) && ctimep) {
1143 dbug_print(("ioctl", " ctime %x %x", ctimep->tv_sec,
1144 ctimep->tv_nsec));
1145 }
1146 dbug_leave("kmod_remove");
1147 return (error);
1148 }
1149
1150 /*
1151 * ------------------------------------------------------------
1152 * kmod_link
1153 *
1154 * Description:
1155 * Arguments:
1156 * dirfidp
1157 * namep
1158 * filefidp
1159 * credp
1160 * ctimep
1161 * Returns:
1162 * Returns ...
1163 * Preconditions:
1164 * precond(dirfidp)
1165 * precond(namep)
1166 * precond(filefidp)
1167 * precond(credp)
1168 */
1169 int
1170 kmod_link(cfsd_kmod_object_t *kmod_object_p,
1171 const cfs_fid_t *dirfidp,
1172 const char *namep,
1173 const cfs_fid_t *filefidp,
1174 const cfs_cid_t *cidp,
1175 const dl_cred_t *credp,
1176 cfs_timestruc_t *ctimep)
1177 {
1178 cachefsio_link_t info;
1179 int error = 0;
1180 int xx;
1181
1182 dbug_enter("kmod_link");
1183 dbug_precond(kmod_object_p);
1184
1185 dbug_precond(dirfidp);
1186 dbug_precond(namep);
1187 dbug_precond(filefidp);
1188 dbug_precond(cidp);
1189 dbug_precond(credp);
1190 dbug_precond(ctimep);
1191
1192 info.ln_dirfid = *dirfidp;
1193 dbug_assert(strlen(namep) < (size_t)MAXNAMELEN);
1194 strlcpy(info.ln_name, namep, sizeof (info.ln_name));
1195 info.ln_filefid = *filefidp;
1196 info.ln_cid = *cidp;
1197 copy_cred(&info.ln_cred, credp);
1198
1199 xx = kmod_doioctl(kmod_object_p, CFSDCMD_LINK, &info, sizeof (info),
1200 ctimep, sizeof (*ctimep));
1201 if (xx)
1202 error = errno;
1203
1204 dbug_print(("ioctl", "returns %d, error %d", xx, error));
1205 kmod_format_fid(kmod_object_p, dirfidp);
1206 dbug_print(("ioctl", " dir fid '%s'", kmod_object_p->i_fidbuf));
1207 dbug_print(("ioctl", " name '%s'", namep));
1208 kmod_format_fid(kmod_object_p, filefidp);
1209 dbug_print(("ioctl", " file fid '%s'", kmod_object_p->i_fidbuf));
1210 kmod_print_cred(credp);
1211 if (xx == 0) {
1212 dbug_print(("ioctl", " ctime %x %x", ctimep->tv_sec,
1213 ctimep->tv_nsec));
1214 }
1215 dbug_leave("kmod_link");
1216 return (error);
1217 }
1218
1219 /*
1220 * ------------------------------------------------------------
1221 * kmod_mkdir
1222 *
1223 * Description:
1224 * Arguments:
1225 * dirfidp
1226 * namep
1227 * vattrp
1228 * credp
1229 * newfidp
1230 * Returns:
1231 * Returns ...
1232 * Preconditions:
1233 * precond(dirfidp)
1234 * precond(namep)
1235 * precond(vattrp)
1236 * precond(credp)
1237 * precond(newfidp)
1238 */
1239 int
1240 kmod_mkdir(cfsd_kmod_object_t *kmod_object_p,
1241 const cfs_fid_t *dirfidp,
1242 const char *namep,
1243 const cfs_cid_t *cidp,
1244 const vattr_t *vattrp,
1245 const dl_cred_t *credp,
1246 cfs_fid_t *newfidp)
1247 {
1248 cachefsio_mkdir_t info;
1249 int error = 0;
1250 int xx;
1251
1252 dbug_enter("kmod_mkdir");
1253 dbug_precond(kmod_object_p);
1254
1255 dbug_precond(dirfidp);
1256 dbug_precond(namep);
1257 dbug_precond(cidp);
1258 dbug_precond(vattrp);
1259 dbug_precond(credp);
1260 dbug_precond(newfidp);
1261
1262 info.md_dirfid = *dirfidp;
1263 dbug_assert(strlen(namep) < (size_t)MAXNAMELEN);
1264 strlcpy(info.md_name, namep, sizeof (info.md_name));
1265 info.md_cid = *cidp;
1266 info.md_vattr = *vattrp;
1267 copy_cred(&info.md_cred, credp);
1268
1269 xx = kmod_doioctl(kmod_object_p, CFSDCMD_MKDIR, &info, sizeof (info),
1270 newfidp, sizeof (*newfidp));
1271 if (xx)
1272 error = errno;
1273
1274 dbug_print(("ioctl", "returns %d, error %d", xx, error));
1275 kmod_format_fid(kmod_object_p, dirfidp);
1276 dbug_print(("ioctl", " dir fid '%s'", kmod_object_p->i_fidbuf));
1277 dbug_print(("ioctl", " name '%s'", namep));
1278 kmod_print_attr(vattrp);
1279 kmod_print_cred(credp);
1280 if (xx == 0) {
1281 kmod_format_fid(kmod_object_p, newfidp);
1282 dbug_print(("ioctl", " file fid '%s'",
1283 kmod_object_p->i_fidbuf));
1284 }
1285 dbug_leave("kmod_mkdir");
1286 return (error);
1287 }
1288
1289 /*
1290 * ------------------------------------------------------------
1291 * kmod_rmdir
1292 *
1293 * Description:
1294 * Arguments:
1295 * dirfidp
1296 * namep
1297 * credp
1298 * Returns:
1299 * Returns ...
1300 * Preconditions:
1301 * precond(dirfidp)
1302 * precond(namep)
1303 * precond(credp)
1304 */
1305 int
1306 kmod_rmdir(cfsd_kmod_object_t *kmod_object_p,
1307 const cfs_fid_t *dirfidp,
1308 const char *namep,
1309 const dl_cred_t *credp)
1310 {
1311 cachefsio_rmdir_t info;
1312 int error = 0;
1313 int xx;
1314
1315 dbug_enter("kmod_rmdir");
1316 dbug_precond(kmod_object_p);
1317
1318 dbug_precond(dirfidp);
1319 dbug_precond(namep);
1320 dbug_precond(credp);
1321
1322 info.rd_dirfid = *dirfidp;
1323 dbug_assert(strlen(namep) < (size_t)MAXNAMELEN);
1324 strlcpy(info.rd_name, namep, sizeof (info.rd_name));
1325 copy_cred(&info.rd_cred, credp);
1326
1327 xx = kmod_doioctl(kmod_object_p, CFSDCMD_RMDIR, &info, sizeof (info),
1328 NULL, 0);
1329 if (xx)
1330 error = errno;
1331
1332 dbug_print(("ioctl", "returns %d, error %d", xx, error));
1333 kmod_format_fid(kmod_object_p, dirfidp);
1334 dbug_print(("ioctl", " dir fid '%s'", kmod_object_p->i_fidbuf));
1335 dbug_print(("ioctl", " name '%s'", namep));
1336 kmod_print_cred(credp);
1337 dbug_leave("kmod_rmdir");
1338 return (error);
1339 }
1340
1341 /*
1342 * ------------------------------------------------------------
1343 * kmod_symlink
1344 *
1345 * Description:
1346 * Arguments:
1347 * dirfidp
1348 * namep
1349 * linkvalp
1350 * vattrp
1351 * credp
1352 * ctimep
1353 * mtimep
1354 * Returns:
1355 * Returns ...
1356 * Preconditions:
1357 * precond(dirfidp)
1358 * precond(namep)
1359 * precond(linkvalp)
1360 * precond(vattrp)
1361 * precond(credp)
1362 * precond(ctimep)
1363 * precond(mtimep)
1364 */
1365 int
1366 kmod_symlink(cfsd_kmod_object_t *kmod_object_p,
1367 const cfs_fid_t *dirfidp,
1368 const char *namep,
1369 const cfs_cid_t *cidp,
1370 const char *linkvalp,
1371 const vattr_t *vattrp,
1372 const dl_cred_t *credp,
1373 cfs_fid_t *newfidp,
1374 cfs_timestruc_t *ctimep,
1375 cfs_timestruc_t *mtimep)
1376 {
1377 cachefsio_symlink_arg_t info;
1378 cachefsio_symlink_return_t ret;
1379 int error = 0;
1380 int xx;
1381
1382 dbug_enter("kmod_symlink");
1383 dbug_precond(kmod_object_p);
1384
1385 dbug_precond(dirfidp);
1386 dbug_precond(namep);
1387 dbug_precond(cidp);
1388 dbug_precond(linkvalp);
1389 dbug_precond(vattrp);
1390 dbug_precond(credp);
1391 dbug_precond(newfidp);
1392 dbug_precond(ctimep);
1393 dbug_precond(mtimep);
1394
1395 info.sy_dirfid = *dirfidp;
1396 dbug_assert(strlen(namep) < (size_t)MAXNAMELEN);
1397 strlcpy(info.sy_name, namep, sizeof (info.sy_name));
1398 dbug_assert(strlen(linkvalp) < (size_t)MAXPATHLEN);
1399 info.sy_cid = *cidp;
1400 strlcpy(info.sy_link, linkvalp, sizeof (info.sy_link));
1401 info.sy_vattr = *vattrp;
1402 copy_cred(&info.sy_cred, credp);
1403
1404 xx = kmod_doioctl(kmod_object_p, CFSDCMD_SYMLINK, &info, sizeof (info),
1405 &ret, sizeof (ret));
1406 if (xx)
1407 error = errno;
1408
1409 dbug_print(("ioctl", "returns %d, error %d", xx, error));
1410 kmod_format_fid(kmod_object_p, dirfidp);
1411 dbug_print(("ioctl", " dir fid '%s'", kmod_object_p->i_fidbuf));
1412 dbug_print(("ioctl", " name '%s'", namep));
1413 dbug_print(("ioctl", " link '%s'", linkvalp));
1414 kmod_print_attr(vattrp);
1415 kmod_print_cred(credp);
1416 if (xx == 0) {
1417 *ctimep = ret.sy_ctime;
1418 *mtimep = ret.sy_mtime;
1419 *newfidp = ret.sy_newfid;
1420 dbug_print(("ioctl", " ctime %x %x", ctimep->tv_sec,
1421 ctimep->tv_nsec));
1422 dbug_print(("ioctl", " mtime %x %x", mtimep->tv_sec,
1423 mtimep->tv_nsec));
1424 kmod_format_fid(kmod_object_p, newfidp);
1425 dbug_print(("ioctl", " child fid '%s'",
1426 kmod_object_p->i_fidbuf));
1427 }
1428 dbug_leave("kmod_symlink");
1429 return (error);
1430 }
1431 #ifndef DBUG_OFF
1432 /*
1433 * ------------------------------------------------------------
1434 * kmod_format_fid
1435 *
1436 * Description:
1437 * Arguments:
1438 * fidp
1439 * Returns:
1440 * Preconditions:
1441 * precond(fidp)
1442 */
1443 void
1444 kmod_format_fid(cfsd_kmod_object_t *kmod_object_p, const cfs_fid_t *fidp)
1445 {
1446 uint_t val;
1447 int index;
1448 char format[10];
1449 kmod_object_p->i_fidbuf[0] = '\0';
1450
1451 for (index = 0; index < (int)fidp->fid_len; index += sizeof (uint_t)) {
1452 memcpy(&val, &fidp->fid_data[index], sizeof (uint_t));
1453 snprintf(format, sizeof (format), "%08x ", val);
1454 strlcat(kmod_object_p->i_fidbuf, format,
1455 sizeof (kmod_object_p->i_fidbuf));
1456 }
1457 }
1458
1459 /*
1460 * ------------------------------------------------------------
1461 * kmod_print_cred
1462 *
1463 * Description:
1464 * Arguments:
1465 * credp
1466 * Returns:
1467 * Preconditions:
1468 * precond(credp)
1469 */
1470 void
1471 kmod_print_cred(const dl_cred_t *credp)
1472 {
1473 char buf[100];
1474 char format[10];
1475 int xx;
1476
1477 dbug_enter("kmod_print_cred");
1478 dbug_precond(credp);
1479
1480 buf[0] = '\0';
1481 dbug_print(("ioctl", "credentials"));
1482 dbug_print(("ioctl", " uid %d, gid %d",
1483 credp->cr_uid, credp->cr_gid));
1484 dbug_print(("ioctl", " ruid %d, rgid %d, suid %d, sgid %d",
1485 credp->cr_ruid, credp->cr_rgid,
1486 credp->cr_suid, credp->cr_sgid));
1487
1488 for (xx = 0; xx < credp->cr_ngroups; xx++) {
1489 snprintf(format, sizeof (format), " %d", credp->cr_groups[xx]);
1490 strlcat(buf, format, sizeof (buf));
1491 }
1492
1493 dbug_print(("ioctl", " ngroups %d, %s", credp->cr_ngroups, buf));
1494 dbug_leave("kmod_print_cred");
1495 }
1496
1497 /*
1498 * ------------------------------------------------------------
1499 * kmod_print_attr
1500 *
1501 * Description:
1502 * Arguments:
1503 * vattrp
1504 * Returns:
1505 * Preconditions:
1506 * precond(vattrp)
1507 */
1508 void
1509 kmod_print_attr(const vattr_t *vp)
1510 {
1511 dbug_enter("kmod_print_attr");
1512 dbug_precond(vp);
1513
1514 dbug_print(("ioctl", "attributes"));
1515 dbug_print(("ioctl", " mask 0x%x", vp->va_mask));
1516 if (vp->va_mask & AT_TYPE)
1517 dbug_print(("ioctl", " type %d", vp->va_type));
1518 if (vp->va_mask & AT_MODE)
1519 dbug_print(("ioctl", " mode 0%o", vp->va_mode));
1520 if (vp->va_mask & AT_UID)
1521 dbug_print(("ioctl", " uid %d", vp->va_uid));
1522 if (vp->va_mask & AT_GID)
1523 dbug_print(("ioctl", " gid %d", vp->va_gid));
1524 if (vp->va_mask & AT_FSID)
1525 dbug_print(("ioctl", " fsid %08x", vp->va_fsid));
1526 if (vp->va_mask & AT_NODEID)
1527 dbug_print(("ioctl", " nodeid %08x", vp->va_nodeid));
1528 if (vp->va_mask & AT_NLINK)
1529 dbug_print(("ioctl", " nlink %d", vp->va_nlink));
1530 if (vp->va_mask & AT_SIZE)
1531 dbug_print(("ioctl", " size %d", vp->va_size));
1532 if (vp->va_mask & AT_ATIME)
1533 dbug_print(("ioctl", " atime %08x %08x",
1534 vp->va_atime.tv_sec, vp->va_atime.tv_nsec));
1535 if (vp->va_mask & AT_MTIME)
1536 dbug_print(("ioctl", " mtime %08x %08x",
1537 vp->va_mtime.tv_sec, vp->va_mtime.tv_nsec));
1538 if (vp->va_mask & AT_CTIME)
1539 dbug_print(("ioctl", " ctime %08x %08x",
1540 vp->va_ctime.tv_sec, vp->va_ctime.tv_nsec));
1541 if (vp->va_mask & AT_RDEV)
1542 dbug_print(("ioctl", " rdev %08x", vp->va_rdev));
1543 if (vp->va_mask & AT_BLKSIZE)
1544 dbug_print(("ioctl", " blksize %08x", vp->va_blksize));
1545 if (vp->va_mask & AT_NBLOCKS)
1546 dbug_print(("ioctl", " nblocks %d", vp->va_nblocks));
1547 if (vp->va_mask & AT_SEQ)
1548 dbug_print(("ioctl", " seq %d", vp->va_seq));
1549 dbug_leave("kmod_print_attr");
1550 }
1551 #endif /* DBUG_OFF */
1552 /*
1553 * kmod_doioctl
1554 *
1555 * Description:
1556 * Helper routine for others in this file. Just packages up
1557 * arguments and does the ioctl operation.
1558 * Arguments:
1559 * cmd
1560 * sdata
1561 * slen
1562 * rdata
1563 * rlen
1564 * Returns:
1565 * Returns the result of the ioctl operation.
1566 * Preconditions:
1567 */
1568 int
1569 kmod_doioctl(cfsd_kmod_object_t *kmod_object_p,
1570 enum cfsdcmd_cmds cmd,
1571 void *sdata,
1572 int slen,
1573 void *rdata,
1574 int rlen)
1575 {
1576 cachefsio_dcmd_t dcmd;
1577 int xx;
1578
1579 dbug_enter("kmod_doioctl");
1580 dbug_precond(kmod_object_p);
1581 dcmd.d_cmd = cmd;
1582 dcmd.d_sdata = sdata;
1583 dcmd.d_slen = slen;
1584 dcmd.d_rdata = rdata;
1585 dcmd.d_rlen = rlen;
1586 dbug_print(("ioctl", "about to do cmd = %d", cmd));
1587 xx = ioctl(kmod_object_p->i_fd, CACHEFSIO_DCMD, &dcmd);
1588 if (xx) {
1589 dbug_print(("ioctl", "ioctl errno = %d", errno));
1590 }
1591 dbug_leave("kmod_doioctl");
1592 return (xx);
1593 }