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 1994-2002 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 * Methods of the cfsd_maptbl classes.
31 */
32
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <stddef.h>
36 #include <string.h>
37 #include <synch.h>
38 #include <unistd.h>
39 #include <fcntl.h>
40 #include <errno.h>
41 #include <sys/utsname.h>
42 #include <sys/vfs.h>
43 #include <sys/cred.h>
44 #include <sys/param.h>
45 #include <sys/types.h>
46 #include <sys/stat.h>
47 #include <sys/mman.h>
48 #include <sys/fs/cachefs_fs.h>
49 #include <sys/fs/cachefs_dlog.h>
50 #include <mdbug/mdbug.h>
51 #include "cfsd.h"
52 #include "cfsd_maptbl.h"
53
54 /*
55 * cfsd_maptbl_create
56 *
57 * Description:
58 * Constructor for the cfsd_maptbl class.
59 * Just does some setup not much else.
60 * Arguments:
61 * Returns:
62 * Preconditions:
63 */
64 cfsd_maptbl_object_t *
65 cfsd_maptbl_create(void)
66 {
67 cfsd_maptbl_object_t *maptbl_object_p;
68
69 dbug_enter("cfsd_maptbl_create");
70
71 maptbl_object_p = cfsd_calloc(sizeof (cfsd_maptbl_object_t));
72
73 maptbl_object_p->i_fid = -1;
74 maptbl_object_p->i_pa = NULL;
75 maptbl_object_p->i_paoff = 0;
76 maptbl_object_p->i_paend = 0;
77 maptbl_object_p->i_palen = 0;
78 dbug_leave("cfsd_maptbl_create");
79 return (maptbl_object_p);
80 }
81
82 /*
83 * cfsd_maptbl_destroy
84 *
85 * Description:
86 * Destructor for the cfsd_maptbl class.
87 * Arguments:
88 * Returns:
89 * Preconditions:
90 */
91 void
92 cfsd_maptbl_destroy(cfsd_maptbl_object_t *maptbl_object_p)
93 {
94 dbug_enter("cfsd_maptbl_destroy");
95 dbug_precond(maptbl_object_p);
96 maptbl_teardown(maptbl_object_p);
97 cfsd_free(maptbl_object_p);
98 dbug_leave("cfsd_maptbl_destroy");
99 }
100
101 /*
102 * maptbl_domap
103 *
104 * Description:
105 * Maps in the specified section of the file.
106 * Arguments:
107 * off The offset to map in. Must be i_pagesize aligned.
108 * Returns:
109 * Returns 0 for success or an errno value on failure.
110 * Preconditions:
111 */
112 int
113 maptbl_domap(cfsd_maptbl_object_t *maptbl_object_p, off_t off)
114 {
115 int xx;
116 int len;
117
118 dbug_enter("maptbl_domap");
119 dbug_precond(maptbl_object_p);
120 dbug_precond(maptbl_object_p->i_fid >= 0);
121
122 len = maptbl_object_p->i_maplen;
123
124 maptbl_object_p->i_stat_mapmove++;
125
126 /* destroy old mapping if it exists */
127 if (maptbl_object_p->i_pa) {
128 /* determine how far we have to move the map */
129 maptbl_object_p->i_stat_mapdist +=
130 abs(maptbl_object_p->i_paoff - off);
131
132 /* remove the map */
133 xx = munmap(maptbl_object_p->i_pa, maptbl_object_p->i_palen);
134 if (xx == -1) {
135 xx = errno;
136 dbug_print(("error", "Could not unmap %s, %d, %p, %d",
137 maptbl_object_p->i_name, xx, maptbl_object_p->i_pa,
138 maptbl_object_p->i_palen));
139 }
140 maptbl_object_p->i_pa = NULL;
141 maptbl_object_p->i_palen = 0;
142 maptbl_object_p->i_paoff = 0;
143 maptbl_object_p->i_paend = 0;
144 }
145
146 /* do the mapping */
147 maptbl_object_p->i_pa =
148 mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED,
149 maptbl_object_p->i_fid, off);
150 if (maptbl_object_p->i_pa == MAP_FAILED) {
151 xx = errno;
152 dbug_print(("error",
153 "Could not map %s, error %d, off %d, len %d",
154 maptbl_object_p->i_name, xx, off, len));
155 maptbl_object_p->i_pa = NULL;
156 dbug_leave("maptbl_domap");
157 return (xx);
158 }
159
160 maptbl_object_p->i_palen = len;
161 maptbl_object_p->i_paoff = off;
162 maptbl_object_p->i_paend = off + len - 1;
163 dbug_leave("maptbl_domap");
164 return (0);
165 }
166
167 /*
168 * maptbl_getaddr
169 *
170 * Description:
171 * Returns an address of a particular entry in the file.
172 * Arguments:
173 * index
174 * Returns:
175 * Returns NULL for a failure with the mapping file.
176 * Preconditions:
177 */
178 caddr_t
179 maptbl_getaddr(cfsd_maptbl_object_t *maptbl_object_p, int index)
180 {
181 off_t start;
182 off_t end;
183 caddr_t pa;
184
185 dbug_enter("maptbl_getaddr");
186 dbug_precond(maptbl_object_p);
187 dbug_precond(index < maptbl_object_p->i_entries);
188
189 /* find the boundaries of the entry */
190 start = index * sizeof (struct cfs_dlog_mapping_space);
191 end = start + sizeof (struct cfs_dlog_mapping_space) - 1;
192
193 /* map the entry in if necessary */
194 if ((start < maptbl_object_p->i_paoff) ||
195 (maptbl_object_p->i_paend < end)) {
196 if (maptbl_domap(maptbl_object_p,
197 start & maptbl_object_p->i_pagemask)) {
198 dbug_leave("maptbl_getaddr");
199 return (NULL);
200 }
201 }
202
203 /* make an address and return it */
204 pa = maptbl_object_p->i_pa + (start - maptbl_object_p->i_paoff);
205 dbug_leave("maptbl_getaddr");
206 return (pa);
207 }
208
209 /*
210 * maptbl_cidhashaddr
211 *
212 * Description:
213 * Finds the address of the specified cid by hashing to
214 * the appropriate entry. If the cid does not already
215 * exist in the file, then the address of where it should
216 * reside is returned.
217 * Arguments:
218 * cid
219 * addrp
220 * Returns:
221 * Returns 0 for success, 1 if entry not found, -1 if an
222 * error occurs in the mapping file.
223 * Preconditions:
224 */
225 int
226 maptbl_cidhashaddr(cfsd_maptbl_object_t *maptbl_object_p,
227 cfs_cid_t cid,
228 caddr_t *addrp)
229 {
230 ino64_t *pa;
231 int index;
232 ino64_t fileno;
233 int start_index;
234
235 dbug_enter("maptbl_cidhashaddr");
236 dbug_precond(maptbl_object_p);
237 dbug_precond(addrp);
238
239 maptbl_object_p->i_stat_requests++;
240
241 /* get the index from the first hash function */
242 index = maptbl_hash1(maptbl_object_p, cid);
243
244 maptbl_object_p->i_stat_probes++;
245
246 /* get the address of the entry */
247 pa = (ino64_t *)maptbl_getaddr(maptbl_object_p, index);
248 if (pa == NULL) {
249 dbug_leave("maptbl_cidhashaddr");
250 return (-1);
251 }
252 fileno = *pa;
253
254 /* check for match */
255 if (fileno == cid.cid_fileno) {
256 *addrp = (caddr_t)pa;
257 dbug_leave("maptbl_cidhashaddr");
258 return (0);
259 }
260
261 /* check for not found */
262 if (fileno == 0) {
263 *addrp = (caddr_t)pa;
264 dbug_leave("maptbl_cidhashaddr");
265 return (1);
266 }
267
268 /* get the index from the second hash function */
269 index = maptbl_hash2(maptbl_object_p, cid, index);
270
271 /* do a linear search for a match or empty entry */
272 start_index = index;
273 do {
274 maptbl_object_p->i_stat_probes++;
275
276 /* get the address of the entry */
277 pa = (ino64_t *)maptbl_getaddr(maptbl_object_p, index);
278 if (pa == NULL) {
279 dbug_leave("maptbl_cidhashaddr");
280 return (-1);
281 }
282 fileno = *pa;
283
284 /* check for match */
285 if (fileno == cid.cid_fileno) {
286 *addrp = (caddr_t)pa;
287 dbug_leave("maptbl_cidhashaddr");
288 return (0);
289 }
290
291 /* check for not found */
292 if (fileno == 0) {
293 *addrp = (caddr_t)pa;
294 dbug_leave("maptbl_cidhashaddr");
295 return (1);
296 }
297
298 /* move to the next entry */
299 index++;
300 index = index % maptbl_object_p->i_entries;
301 } while (start_index != index);
302
303 /* table full, this is bad */
304 dbug_print(("error", "Table is full"));
305 dbug_leave("maptbl_cidhashaddr");
306 return (-1);
307 }
308
309 /*
310 * maptbl_hash1
311 *
312 * Description:
313 * Hashes a cid into an index into the table.
314 * Arguments:
315 * cid
316 * Returns:
317 * Returns the index.
318 * Preconditions:
319 */
320 int
321 maptbl_hash1(cfsd_maptbl_object_t *maptbl_object_p, cfs_cid_t cid)
322 {
323 unsigned int xx;
324 unsigned int a, b;
325
326 dbug_precond(maptbl_object_p);
327 #if 0
328 xx = cid.cid_fileno % i_entries;
329 #else
330 a = cid.cid_fileno >> 16;
331 b = a ^ cid.cid_fileno;
332 xx = b % maptbl_object_p->i_entries;
333 #endif
334 return (xx);
335 }
336
337 /*
338 * maptbl_hash2
339 *
340 * Description:
341 * Hashes a cid into an index into the table.
342 * Arguments:
343 * cid
344 * index
345 * Returns:
346 * Returns the index.
347 * Preconditions:
348 */
349 int
350 maptbl_hash2(cfsd_maptbl_object_t *maptbl_object_p, cfs_cid_t cid, int index)
351 {
352 unsigned int xx;
353 unsigned int a, b, c, d;
354
355 dbug_precond(maptbl_object_p);
356 #if 0
357 a = cid.cid_fileno & 0x0ff;
358 b = (cid.cid_fileno >> 8) & 0x0ff;
359 b = cid.cid_fileno ^ a ^ b;
360 xx = b % maptbl_object_p->i_hash2mod;
361 #else
362 a = cid.cid_fileno & 0x0ff;
363 b = (cid.cid_fileno >> 8) & 0x0ff;
364 c = (cid.cid_fileno >> 16) & 0x0ff;
365 d = (cid.cid_fileno >> 24) & 0x0ff;
366 xx = cid.cid_fileno ^ (a << 8) ^ b ^ c ^ d;
367 xx = xx % maptbl_object_p->i_hash2mod;
368 #endif
369 xx = (index + xx) % maptbl_object_p->i_entries;
370 return (xx);
371 }
372
373 /*
374 * maptbl_setup
375 *
376 * Description:
377 * Performs setup for the cfsd_maptbl class.
378 * This routine must be called before other routines are used.
379 * Arguments:
380 * filename
381 * Returns:
382 * Returns 0 for success or an errno value.
383 * Preconditions:
384 * precond(filename)
385 */
386 int
387 maptbl_setup(cfsd_maptbl_object_t *maptbl_object_p, const char *filename)
388 {
389 int xx;
390 struct stat sinfo;
391 off_t offset;
392 long *lp;
393 size_t cnt;
394 off_t size;
395
396 dbug_enter("maptbl_setup");
397 dbug_precond(maptbl_object_p);
398 dbug_precond(filename);
399
400 /* clean up from a previous setup */
401 maptbl_teardown(maptbl_object_p);
402
403 strlcpy(maptbl_object_p->i_name, filename,
404 sizeof (maptbl_object_p->i_name));
405 dbug_print(("info", "filename %s", maptbl_object_p->i_name));
406
407 /* get the page info */
408 maptbl_object_p->i_pagesize = PAGESIZE;
409 maptbl_object_p->i_pagemask = PAGEMASK;
410 maptbl_object_p->i_maplen = maptbl_object_p->i_pagesize * 100;
411
412 /* open the file */
413 maptbl_object_p->i_fid = open(maptbl_object_p->i_name,
414 O_RDWR | O_NONBLOCK);
415 if (maptbl_object_p->i_fid == -1) {
416 xx = errno;
417 dbug_print(("error",
418 "Could not open %s, %d", maptbl_object_p->i_name, xx));
419 dbug_leave("maptbl_setup");
420 return (xx);
421 }
422
423 /* get the size and type of file */
424 xx = fstat(maptbl_object_p->i_fid, &sinfo);
425 if (xx) {
426 xx = errno;
427 dbug_print(("error",
428 "Could not stat %s, %d", maptbl_object_p->i_name, xx));
429 dbug_leave("maptbl_setup");
430 return (xx);
431 }
432 maptbl_object_p->i_size = sinfo.st_size;
433
434 /* sanity check, better be a regular file */
435 if (!S_ISREG(sinfo.st_mode)) {
436 xx = ENOTSUP;
437 dbug_print(("error",
438 "%s Not a regular file.", maptbl_object_p->i_name));
439 dbug_leave("maptbl_setup");
440 return (xx);
441 }
442
443 /* determine number of entries */
444 maptbl_object_p->i_entries =
445 maptbl_object_p->i_size / sizeof (struct cfs_dlog_mapping_space);
446
447 /* set up modulo value for second hash function */
448 maptbl_object_p->i_hash2mod = (maptbl_object_p->i_entries / 2) + 1;
449
450 /* initialize statistic gathering */
451 maptbl_object_p->i_stat_requests = 0;
452 maptbl_object_p->i_stat_probes = 0;
453 maptbl_object_p->i_stat_mapmove = 0;
454 maptbl_object_p->i_stat_mapdist = 0;
455 maptbl_object_p->i_stat_filled = 0;
456
457 /* zero the file */
458 for (offset = 0; offset < maptbl_object_p->i_size;
459 offset += maptbl_object_p->i_maplen) {
460 /* map in a section of the file */
461 xx = maptbl_domap(maptbl_object_p, offset);
462 if (xx) {
463 dbug_leave("maptbl_setup");
464 return (xx);
465 }
466 /* zero this section of the file */
467 lp = (long *)maptbl_object_p->i_pa;
468 size = maptbl_object_p->i_size - offset;
469 if (size < maptbl_object_p->i_palen) {
470 cnt = size / sizeof (long);
471 } else {
472 cnt = maptbl_object_p->i_palen / sizeof (long);
473 dbug_assert((cnt * sizeof (long)) ==
474 maptbl_object_p->i_palen);
475 }
476 memset(lp, 0, cnt * sizeof (*lp));
477 }
478
479 /* return success */
480 dbug_leave("maptbl_setup");
481 return (0);
482 }
483
484 /*
485 * maptbl_teardown
486 *
487 * Description:
488 * Arguments:
489 * Returns:
490 * Preconditions:
491 */
492 void
493 maptbl_teardown(cfsd_maptbl_object_t *maptbl_object_p)
494 {
495 int xx;
496
497 dbug_enter("maptbl_teardown");
498 dbug_precond(maptbl_object_p);
499
500 if (maptbl_object_p->i_pa) {
501 xx = munmap(maptbl_object_p->i_pa, maptbl_object_p->i_palen);
502 if (xx == -1) {
503 xx = errno;
504 dbug_print(("error", "Could not unmap %s, %d, %p, %d",
505 maptbl_object_p->i_name, xx, maptbl_object_p->i_pa,
506 maptbl_object_p->i_palen));
507 }
508 maptbl_object_p->i_pa = NULL;
509 }
510 maptbl_object_p->i_paoff = 0;
511 maptbl_object_p->i_paend = 0;
512 maptbl_object_p->i_palen = 0;
513
514 if (maptbl_object_p->i_fid != -1) {
515 if (close(maptbl_object_p->i_fid))
516 dbug_print(("err", "cannot close maptbl fd, error %d",
517 errno));
518 maptbl_object_p->i_fid = -1;
519 }
520 dbug_leave("maptbl_teardown");
521 }
522
523 /*
524 * maptbl_get
525 *
526 * Description:
527 * Gets the mapping info for the specified cid.
528 * Arguments:
529 * cid
530 * valuep
531 * Returns:
532 * Returns 0 for success, 1 if entry not found, -1 if an
533 * error occurs in the mapping file.
534 * Preconditions:
535 * precond(valuep)
536 */
537 int
538 maptbl_get(cfsd_maptbl_object_t *maptbl_object_p,
539 cfs_cid_t cid,
540 struct cfs_dlog_mapping_space *valuep)
541 {
542 int xx;
543 struct cfs_dlog_mapping_space *pa;
544
545 dbug_enter("maptbl_get");
546 dbug_precond(maptbl_object_p);
547 dbug_precond(valuep);
548
549 if (maptbl_object_p->i_entries == 0) {
550 dbug_leave("maptbl_get");
551 return (1);
552 }
553 xx = maptbl_cidhashaddr(maptbl_object_p, cid, (caddr_t *)&pa);
554 if (xx == 0)
555 *valuep = *pa;
556 dbug_leave("maptbl_get");
557 return (xx);
558 }
559
560 /*
561 * maptbl_set
562 *
563 * Description:
564 * Sets the mapping info for the cid.
565 * If insert is 1 then if the entry is not found it is put in the
566 * table.
567 * Arguments:
568 * valuep
569 * insert
570 * Returns:
571 * Returns 0 if mapping info placed in the table, 1 if entry
572 * is not found an insert is 0, -1 if an error occurs in the
573 * mapping file.
574 * Preconditions:
575 * precond(valuep)
576 */
577 int
578 maptbl_set(cfsd_maptbl_object_t *maptbl_object_p,
579 struct cfs_dlog_mapping_space *valuep,
580 int insert)
581 {
582 int xx;
583 struct cfs_dlog_mapping_space *pa;
584
585 dbug_enter("maptbl_set");
586 dbug_precond(maptbl_object_p);
587 dbug_precond(valuep);
588
589 dbug_assert(maptbl_object_p->i_entries > 0);
590
591 xx = maptbl_cidhashaddr(maptbl_object_p, valuep->ms_cid,
592 (caddr_t *)&pa);
593 if ((xx == 0) || ((xx == 1) && insert)) {
594 *pa = *valuep;
595 if (xx == 1)
596 maptbl_object_p->i_stat_filled++;
597 xx = 0;
598 }
599 dbug_leave("maptbl_set");
600 return (xx);
601 }
602
603 /*
604 * maptbl_dumpstats
605 *
606 * Description:
607 * Prints out various stats about the hashing.
608 * Arguments:
609 * Returns:
610 * Preconditions:
611 */
612 void
613 maptbl_dumpstats(cfsd_maptbl_object_t *maptbl_object_p)
614 {
615 int xx;
616 double dd;
617
618 dbug_enter("maptbl_dumpstats");
619 dbug_precond(maptbl_object_p);
620
621 dbug_print(("dump", "Total Entries %d", maptbl_object_p->i_entries));
622 dbug_print(("dump", "Filled Entries %d",
623 maptbl_object_p->i_stat_filled));
624 dbug_print(("dump", "Requests %d", maptbl_object_p->i_stat_requests));
625 dbug_print(("dump", "Probes %d", maptbl_object_p->i_stat_probes));
626 dbug_print(("dump", "Map Moves %d", maptbl_object_p->i_stat_mapmove));
627 dbug_print(("dump", "Mapping Size %d", maptbl_object_p->i_maplen));
628 dbug_print(("dump", "File Size %d", maptbl_object_p->i_size));
629 if (maptbl_object_p->i_stat_requests == 0) {
630 dbug_leave("maptbl_dumpstats");
631 return;
632 }
633 dd = (double)maptbl_object_p->i_stat_probes /
634 maptbl_object_p->i_stat_requests;
635 dbug_print(("dump", "Probes per Request %.2f", dd));
636
637 dd = (double)maptbl_object_p->i_stat_mapmove /
638 maptbl_object_p->i_stat_requests;
639 dbug_print(("dump", "Mmap moves per Request %.2f", dd));
640
641 xx = maptbl_object_p->i_stat_mapdist / maptbl_object_p->i_stat_mapmove;
642 dbug_print(("dump", "Average distance per mmap moves %d", xx));
643
644 xx = ((100.0 * maptbl_object_p->i_stat_filled) /
645 maptbl_object_p->i_entries) + .5;
646 dbug_print(("dump", "Table filled %d%%", xx));
647
648 dbug_leave("maptbl_dumpstats");
649 }