Annotation of embedaddon/ntp/sntp/libopts/text_mmap.c, revision 1.1
1.1 ! misho 1: /**
! 2: * \file text_mmap.c
! 3: *
! 4: * Time-stamp: "2010-07-17 10:15:32 bkorb"
! 5: *
! 6: * This file is part of AutoOpts, a companion to AutoGen.
! 7: * AutoOpts is free software.
! 8: * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved
! 9: *
! 10: * AutoOpts is available under any one of two licenses. The license
! 11: * in use must be one of these two and the choice is under the control
! 12: * of the user of the license.
! 13: *
! 14: * The GNU Lesser General Public License, version 3 or later
! 15: * See the files "COPYING.lgplv3" and "COPYING.gplv3"
! 16: *
! 17: * The Modified Berkeley Software Distribution License
! 18: * See the file "COPYING.mbsd"
! 19: *
! 20: * These files have the following md5sums:
! 21: *
! 22: * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
! 23: * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
! 24: * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
! 25: */
! 26:
! 27: #ifndef MAP_ANONYMOUS
! 28: # ifdef MAP_ANON
! 29: # define MAP_ANONYMOUS MAP_ANON
! 30: # endif
! 31: #endif
! 32:
! 33: /*
! 34: * Some weird systems require that a specifically invalid FD number
! 35: * get passed in as an argument value. Which value is that? Well,
! 36: * as everybody knows, if open(2) fails, it returns -1, so that must
! 37: * be the value. :)
! 38: */
! 39: #define AO_INVALID_FD -1
! 40:
! 41: #define FILE_WRITABLE(_prt,_flg) \
! 42: ( (_prt & PROT_WRITE) \
! 43: && ((_flg & (MAP_SHARED|MAP_PRIVATE)) == MAP_SHARED))
! 44: #define MAP_FAILED_PTR ((void*)MAP_FAILED)
! 45:
! 46: /*=export_func text_mmap
! 47: * private:
! 48: *
! 49: * what: map a text file with terminating NUL
! 50: *
! 51: * arg: char const*, pzFile, name of the file to map
! 52: * arg: int, prot, mmap protections (see mmap(2))
! 53: * arg: int, flags, mmap flags (see mmap(2))
! 54: * arg: tmap_info_t*, mapinfo, returned info about the mapping
! 55: *
! 56: * ret-type: void*
! 57: * ret-desc: The mmaped data address
! 58: *
! 59: * doc:
! 60: *
! 61: * This routine will mmap a file into memory ensuring that there is at least
! 62: * one @file{NUL} character following the file data. It will return the
! 63: * address where the file contents have been mapped into memory. If there is a
! 64: * problem, then it will return @code{MAP_FAILED} and set @file{errno}
! 65: * appropriately.
! 66: *
! 67: * The named file does not exist, @code{stat(2)} will set @file{errno} as it
! 68: * will. If the file is not a regular file, @file{errno} will be
! 69: * @code{EINVAL}. At that point, @code{open(2)} is attempted with the access
! 70: * bits set appropriately for the requested @code{mmap(2)} protections and flag
! 71: * bits. On failure, @file{errno} will be set according to the documentation
! 72: * for @code{open(2)}. If @code{mmap(2)} fails, @file{errno} will be set as
! 73: * that routine sets it. If @code{text_mmap} works to this point, a valid
! 74: * address will be returned, but there may still be ``issues''.
! 75: *
! 76: * If the file size is not an even multiple of the system page size, then
! 77: * @code{text_map} will return at this point and @file{errno} will be zero.
! 78: * Otherwise, an anonymous map is attempted. If not available, then an attempt
! 79: * is made to @code{mmap(2)} @file{/dev/zero}. If any of these fail, the
! 80: * address of the file's data is returned, bug @code{no} @file{NUL} characters
! 81: * are mapped after the end of the data.
! 82: *
! 83: * see: mmap(2), open(2), stat(2)
! 84: *
! 85: * err: Any error code issued by mmap(2), open(2), stat(2) is possible.
! 86: * Additionally, if the specified file is not a regular file, then
! 87: * errno will be set to @code{EINVAL}.
! 88: *
! 89: * example:
! 90: * #include <mylib.h>
! 91: * tmap_info_t mi;
! 92: * int no_nul;
! 93: * void* data = text_mmap("file", PROT_WRITE, MAP_PRIVATE, &mi);
! 94: * if (data == MAP_FAILED) return;
! 95: * no_nul = (mi.txt_size == mi.txt_full_size);
! 96: * << use the data >>
! 97: * text_munmap(&mi);
! 98: =*/
! 99: void*
! 100: text_mmap(char const* pzFile, int prot, int flags, tmap_info_t* pMI)
! 101: {
! 102: memset(pMI, 0, sizeof(*pMI));
! 103: #ifdef HAVE_MMAP
! 104: pMI->txt_zero_fd = -1;
! 105: #endif
! 106: pMI->txt_fd = -1;
! 107:
! 108: /*
! 109: * Make sure we can stat the regular file. Save the file size.
! 110: */
! 111: {
! 112: struct stat sb;
! 113: if (stat(pzFile, &sb) != 0) {
! 114: pMI->txt_errno = errno;
! 115: return MAP_FAILED_PTR;
! 116: }
! 117:
! 118: if (! S_ISREG(sb.st_mode)) {
! 119: pMI->txt_errno = errno = EINVAL;
! 120: return MAP_FAILED_PTR;
! 121: }
! 122:
! 123: pMI->txt_size = sb.st_size;
! 124: }
! 125:
! 126: /*
! 127: * Map mmap flags and protections into open flags and do the open.
! 128: */
! 129: {
! 130: int o_flag;
! 131: /*
! 132: * See if we will be updating the file. If we can alter the memory
! 133: * and if we share the data and we are *not* copy-on-writing the data,
! 134: * then our updates will show in the file, so we must open with
! 135: * write access.
! 136: */
! 137: if (FILE_WRITABLE(prot,flags))
! 138: o_flag = O_RDWR;
! 139: else
! 140: o_flag = O_RDONLY;
! 141:
! 142: /*
! 143: * If you're not sharing the file and you are writing to it,
! 144: * then don't let anyone else have access to the file.
! 145: */
! 146: if (((flags & MAP_SHARED) == 0) && (prot & PROT_WRITE))
! 147: o_flag |= O_EXCL;
! 148:
! 149: pMI->txt_fd = open(pzFile, o_flag);
! 150: }
! 151:
! 152: if (pMI->txt_fd == AO_INVALID_FD) {
! 153: pMI->txt_errno = errno;
! 154: return MAP_FAILED_PTR;
! 155: }
! 156:
! 157: #ifdef HAVE_MMAP /* * * * * WITH MMAP * * * * * */
! 158: /*
! 159: * do the mmap. If we fail, then preserve errno, close the file and
! 160: * return the failure.
! 161: */
! 162: pMI->txt_data =
! 163: mmap(NULL, pMI->txt_size+1, prot, flags, pMI->txt_fd, (size_t)0);
! 164: if (pMI->txt_data == MAP_FAILED_PTR) {
! 165: pMI->txt_errno = errno;
! 166: goto fail_return;
! 167: }
! 168:
! 169: /*
! 170: * Most likely, everything will turn out fine now. The only difficult
! 171: * part at this point is coping with files with sizes that are a multiple
! 172: * of the page size. Handling that is what this whole thing is about.
! 173: */
! 174: pMI->txt_zero_fd = -1;
! 175: pMI->txt_errno = 0;
! 176:
! 177: {
! 178: void* pNuls;
! 179: #ifdef _SC_PAGESIZE
! 180: size_t pgsz = sysconf(_SC_PAGESIZE);
! 181: #else
! 182: size_t pgsz = getpagesize();
! 183: #endif
! 184: /*
! 185: * Compute the pagesize rounded mapped memory size.
! 186: * IF this is not the same as the file size, then there are NUL's
! 187: * at the end of the file mapping and all is okay.
! 188: */
! 189: pMI->txt_full_size = (pMI->txt_size + (pgsz - 1)) & ~(pgsz - 1);
! 190: if (pMI->txt_size != pMI->txt_full_size)
! 191: return pMI->txt_data;
! 192:
! 193: /*
! 194: * Still here? We have to remap the trailing inaccessible page
! 195: * either anonymously or to /dev/zero.
! 196: */
! 197: pMI->txt_full_size += pgsz;
! 198: #if defined(MAP_ANONYMOUS)
! 199: pNuls = mmap(
! 200: (void*)(((char*)pMI->txt_data) + pMI->txt_size),
! 201: pgsz, PROT_READ|PROT_WRITE,
! 202: MAP_ANONYMOUS|MAP_FIXED|MAP_PRIVATE, AO_INVALID_FD, (size_t)0);
! 203:
! 204: if (pNuls != MAP_FAILED_PTR)
! 205: return pMI->txt_data;
! 206:
! 207: pMI->txt_errno = errno;
! 208:
! 209: #elif defined(HAVE_DEV_ZERO)
! 210: pMI->txt_zero_fd = open("/dev/zero", O_RDONLY);
! 211:
! 212: if (pMI->txt_zero_fd == AO_INVALID_FD) {
! 213: pMI->txt_errno = errno;
! 214:
! 215: } else {
! 216: pNuls = mmap(
! 217: (void*)(((char*)pMI->txt_data) + pMI->txt_size), pgsz,
! 218: PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED,
! 219: pMI->txt_zero_fd, 0 );
! 220:
! 221: if (pNuls != MAP_FAILED_PTR)
! 222: return pMI->txt_data;
! 223:
! 224: pMI->txt_errno = errno;
! 225: close(pMI->txt_zero_fd);
! 226: pMI->txt_zero_fd = -1;
! 227: }
! 228: #endif
! 229:
! 230: pMI->txt_full_size = pMI->txt_size;
! 231: }
! 232:
! 233: {
! 234: void* p = AGALOC(pMI->txt_size+1, "file text");
! 235: memcpy(p, pMI->txt_data, pMI->txt_size);
! 236: ((char*)p)[pMI->txt_size] = NUL;
! 237: munmap(pMI->txt_data, pMI->txt_size );
! 238: pMI->txt_data = p;
! 239: }
! 240: pMI->txt_alloc = 1;
! 241: return pMI->txt_data;
! 242:
! 243: #else /* * * * * * no HAVE_MMAP * * * * * */
! 244:
! 245: pMI->txt_data = AGALOC(pMI->txt_size+1, "file text");
! 246: if (pMI->txt_data == NULL) {
! 247: pMI->txt_errno = ENOMEM;
! 248: goto fail_return;
! 249: }
! 250:
! 251: {
! 252: size_t sz = pMI->txt_size;
! 253: char* pz = pMI->txt_data;
! 254:
! 255: while (sz > 0) {
! 256: ssize_t rdct = read(pMI->txt_fd, pz, sz);
! 257: if (rdct <= 0) {
! 258: pMI->txt_errno = errno;
! 259: fprintf(stderr, zFSErrReadFile,
! 260: errno, strerror(errno), pzFile);
! 261: free(pMI->txt_data);
! 262: goto fail_return;
! 263: }
! 264:
! 265: pz += rdct;
! 266: sz -= rdct;
! 267: }
! 268:
! 269: *pz = NUL;
! 270: }
! 271:
! 272: /*
! 273: * We never need a dummy page mapped in
! 274: */
! 275: pMI->txt_zero_fd = -1;
! 276: pMI->txt_errno = 0;
! 277:
! 278: return pMI->txt_data;
! 279:
! 280: #endif /* * * * * * no HAVE_MMAP * * * * * */
! 281:
! 282: fail_return:
! 283: if (pMI->txt_fd >= 0) {
! 284: close(pMI->txt_fd);
! 285: pMI->txt_fd = -1;
! 286: }
! 287: errno = pMI->txt_errno;
! 288: pMI->txt_data = MAP_FAILED_PTR;
! 289: return pMI->txt_data;
! 290: }
! 291:
! 292:
! 293: /*=export_func text_munmap
! 294: * private:
! 295: *
! 296: * what: unmap the data mapped in by text_mmap
! 297: *
! 298: * arg: tmap_info_t*, mapinfo, info about the mapping
! 299: *
! 300: * ret-type: int
! 301: * ret-desc: -1 or 0. @file{errno} will have the error code.
! 302: *
! 303: * doc:
! 304: *
! 305: * This routine will unmap the data mapped in with @code{text_mmap} and close
! 306: * the associated file descriptors opened by that function.
! 307: *
! 308: * see: munmap(2), close(2)
! 309: *
! 310: * err: Any error code issued by munmap(2) or close(2) is possible.
! 311: =*/
! 312: int
! 313: text_munmap(tmap_info_t* pMI)
! 314: {
! 315: #ifdef HAVE_MMAP
! 316: int res = 0;
! 317: if (pMI->txt_alloc) {
! 318: /*
! 319: * IF the user has write permission and the text is not mapped private,
! 320: * then write back any changes. Hopefully, nobody else has modified
! 321: * the file in the mean time.
! 322: */
! 323: if ( ((pMI->txt_prot & PROT_WRITE) != 0)
! 324: && ((pMI->txt_flags & MAP_PRIVATE) == 0)) {
! 325:
! 326: if (lseek(pMI->txt_fd, (size_t)0, SEEK_SET) != 0)
! 327: goto error_return;
! 328:
! 329: res = (write(pMI->txt_fd, pMI->txt_data, pMI->txt_size) < 0)
! 330: ? errno : 0;
! 331: }
! 332:
! 333: AGFREE(pMI->txt_data);
! 334: errno = res;
! 335: } else {
! 336: res = munmap(pMI->txt_data, pMI->txt_full_size);
! 337: }
! 338: if (res != 0)
! 339: goto error_return;
! 340:
! 341: res = close(pMI->txt_fd);
! 342: if (res != 0)
! 343: goto error_return;
! 344:
! 345: pMI->txt_fd = -1;
! 346: errno = 0;
! 347: if (pMI->txt_zero_fd != -1) {
! 348: res = close(pMI->txt_zero_fd);
! 349: pMI->txt_zero_fd = -1;
! 350: }
! 351:
! 352: error_return:
! 353: pMI->txt_errno = errno;
! 354: return res;
! 355: #else /* HAVE_MMAP */
! 356:
! 357: errno = 0;
! 358: /*
! 359: * IF the memory is writable *AND* it is not private (copy-on-write)
! 360: * *AND* the memory is "sharable" (seen by other processes)
! 361: * THEN rewrite the data.
! 362: */
! 363: if ( FILE_WRITABLE(pMI->txt_prot, pMI->txt_flags)
! 364: && (lseek(pMI->txt_fd, 0, SEEK_SET) >= 0) ) {
! 365: write(pMI->txt_fd, pMI->txt_data, pMI->txt_size);
! 366: }
! 367:
! 368: close(pMI->txt_fd);
! 369: pMI->txt_fd = -1;
! 370: pMI->txt_errno = errno;
! 371: free(pMI->txt_data);
! 372:
! 373: return pMI->txt_errno;
! 374: #endif /* HAVE_MMAP */
! 375: }
! 376:
! 377: /*
! 378: * Local Variables:
! 379: * mode: C
! 380: * c-file-style: "stroustrup"
! 381: * indent-tabs-mode: nil
! 382: * End:
! 383: * end of autoopts/text_mmap.c */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to text_mmap.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / sntp / libopts