|
Search "snprintf" (945 hits in 220 files)
|
|
GitHub\ceph\src\ceph_fuse.cc (1 hit)
|
|
Line 137: snprintf(buf, 5049, "fusermount -u -z %s", mountpoint.c_str());
|
|
GitHub\ceph\src\ceph_mds.cc (3 hits)
|
|
Line 117: snprintf(rb, sizeof(rb), "%d", r);
|
|
Line 130: snprintf(rb, sizeof(rb), "%d", r);
|
|
Line 248: snprintf(s, sizeof(s), "gmon/%d", getpid());
|
|
GitHub\ceph\src\ceph_mon.cc (1 hit)
|
|
Line 787: snprintf(s, sizeof(s), "gmon/%d", getpid());
|
|
GitHub\ceph\src\ceph_osd.cc (1 hit)
|
|
Line 608: snprintf(s, sizeof(s), "gmon/%d", getpid());
|
|
GitHub\ceph\src\civetweb\examples\chat\chat.c (3 hits)
|
|
Line 107: len += snprintf(buf + len, sizeof(buf) - len,
|
|
Line 259: vsnprintf(message->text, sizeof(message->text), fmt, ap);
|
|
Line 290: snprintf(session->random, sizeof(session->random), "%d", rand());
|
|
GitHub\ceph\src\civetweb\examples\hello\hello.c (1 hit)
|
|
Line 12: int content_length = snprintf(content, sizeof(content),
|
|
GitHub\ceph\src\civetweb\examples\ws_server\ws_server.c (1 hit)
|
|
Line 250: snprintf(server_name, sizeof(server_name),
|
|
GitHub\ceph\src\civetweb\src\civetweb.c (69 hits)
|
|
Line 163: #define snprintf _snprintf
|
|
Line 163: #define snprintf _snprintf
|
|
Line 164: #define vsnprintf _vsnprintf
|
|
Line 164: #define vsnprintf _vsnprintf
|
|
Line 998: /* Like snprintf(), but never returns negative value, or a value
|
|
Line 1000: Thanks to Adam Zeldis to pointing snprintf()-caused vulnerability
|
|
Line 1002: static int mg_vsnprintf(struct mg_connection *conn, char *buf, size_t buflen,
|
|
Line 1010: n = vsnprintf(buf, buflen, fmt, ap);
|
|
Line 1013: mg_cry(conn, "vsnprintf error");
|
|
Line 1016: mg_cry(conn, "truncating vsnprintf buffer: [%.*s]",
|
|
Line 1025: static int mg_snprintf(struct mg_connection *conn, char *buf, size_t buflen,
|
|
Line 1029: static int mg_snprintf(struct mg_connection *conn, char *buf, size_t buflen,
|
|
Line 1036: n = mg_vsnprintf(conn, buf, buflen, fmt, ap);
|
|
Line 1116: IGNORE_UNUSED_RESULT(vsnprintf(buf, sizeof(buf), fmt, ap));
|
|
Line 1381: len = mg_snprintf(conn, buf, sizeof(buf)-32, "%serror%03u.", error_handler, status);
|
|
Line 1384: len = mg_snprintf(conn, buf, sizeof(buf)-32, "%serror%01uxx.", error_handler, status/100);
|
|
Line 1387: len = mg_snprintf(conn, buf, sizeof(buf)-32, "%serror.", error_handler);
|
|
Line 1416: len = mg_snprintf(conn, buf, sizeof(buf)-1, "Error %d: %s", status, reason);
|
|
Line 1422: len += mg_vsnprintf(conn, buf + len, sizeof(buf) - len, fmt, ap);
|
|
Line 1692: (void) snprintf(dst, dst_size, "implement strftime() for WinCE");
|
|
Line 1989: snprintf(cmdline, sizeof(cmdline), "%s%c%s", dir, '/', prog);
|
|
Line 2011: mg_snprintf(conn, cmdline, sizeof(cmdline), "%s%s\"%s\\%s\"",
|
|
Line 2408: len = vsnprintf(*buf, size, fmt, ap_copy);
|
|
Line 2423: /* Windows is not standard-compliant, and vsnprintf() returns -1 if
|
|
Line 2425: _vscprintf(). However, if size is 0, vsnprintf() behaves correctly.
|
|
Line 2430: len = vsnprintf(NULL, 0, fmt, ap_copy);
|
|
Line 2434: /* C runtime is not standard compliant, vsnprintf() returned -1.
|
|
Line 2446: IGNORE_UNUSED_RESULT(vsnprintf(*buf, size, fmt, ap_copy));
|
|
Line 2695: mg_snprintf(conn, buf, buf_len - 1, "%s%s",
|
|
Line 2702: mg_snprintf(conn, buf, buf_len - 1, "%.*s%s", (int) b.len, b.ptr,
|
|
Line 2718: snprintf(gz_path, sizeof(gz_path), "%s.gz", buf);
|
|
Line 3084: mg_snprintf(conn, name, sizeof(name), "%s%c%s",
|
|
Line 3098: mg_snprintf(conn, name, sizeof(name), "%.*s%c%s",
|
|
Line 3333: mg_snprintf(conn, fname, sizeof(fname), "%.*s",
|
|
Line 3430: (void) snprintf(tmp, sizeof(tmp) - 1, "%s.tmp", fname);
|
|
Line 3490: snprintf(ebuf, ebuf_len, "%s", "NULL host");
|
|
Line 3492: snprintf(ebuf, ebuf_len, "%s", "SSL is not initialized");
|
|
Line 3495: snprintf(ebuf, ebuf_len, "gethostbyname(%s): %s", host, strerror(ERRNO));
|
|
Line 3497: snprintf(ebuf, ebuf_len, "socket(): %s", strerror(ERRNO));
|
|
Line 3505: snprintf(ebuf, ebuf_len, "connect(%s:%d): %s",
|
|
Line 3545: mg_snprintf(de->conn, size, sizeof(size), "%s", "[DIRECTORY]");
|
|
Line 3550: mg_snprintf(de->conn, size, sizeof(size), "%d", (int) de->file.size);
|
|
Line 3552: mg_snprintf(de->conn, size, sizeof(size),
|
|
Line 3555: mg_snprintf(de->conn, size, sizeof(size),
|
|
Line 3558: mg_snprintf(de->conn, size, sizeof(size),
|
|
Line 3637: mg_snprintf(conn, path, sizeof(path), "%s%c%s", dir, '/', dp->d_name);
|
|
Line 3678: mg_snprintf(conn, path, sizeof(path), "%s%c%s", dir, '/', dp->d_name);
|
|
Line 3853: snprintf(buf, buf_len, "\"%lx.%" INT64_FMT "\"",
|
|
Line 3892: snprintf(gz_path, sizeof(gz_path), "%s.gz", path);
|
|
Line 3919: mg_snprintf(conn, range, sizeof(range),
|
|
Line 4229: n = mg_vsnprintf(block->conn, added, (size_t) space, fmt, ap);
|
|
Line 4387: (void) mg_snprintf(conn, dir, sizeof(dir), "%s", prog);
|
|
Line 4678: (void) mg_snprintf(conn, path, sizeof(path), "%s%c%s",
|
|
Line 4684: (void) mg_snprintf(conn, path, sizeof(path), "%s", file_name);
|
|
Line 4689: (void) mg_snprintf(conn, path, sizeof(path), "%s", ssi);
|
|
Line 4694: (void) mg_snprintf(conn, path + len, sizeof(path) - len, "%s", file_name);
|
|
Line 4892: mg_snprintf(conn, href, sizeof(href), "%s%s",
|
|
Line 5168: mg_snprintf(conn, buf, sizeof(buf), "%s%s",
|
|
Line 5566: snprintf(path, sizeof(path), "%s/%s", destination_dir, s);
|
|
Line 6077: snprintf(buf, sizeof(buf), "%s - %s [%s] \"%s %s HTTP/%s\" %d %" INT64_FMT " %s %s",
|
|
Line 6421: snprintf(ebuf, ebuf_len, "calloc(): %s", strerror(ERRNO));
|
|
Line 6426: snprintf(ebuf, ebuf_len, "SSL_CTX_new error");
|
|
Line 6477: snprintf(ebuf, ebuf_len, "%s", "Request Too Large");
|
|
Line 6481: snprintf(ebuf, ebuf_len, "%s", "Client closed connection");
|
|
Line 6485: snprintf(ebuf, ebuf_len, "Bad request: [%.*s]", conn->data_len, conn->buf);
|
|
Line 6498: snprintf(ebuf, ebuf_len, "%s", "Bad Request");
|
|
Line 6529: snprintf(ebuf, ebuf_len, "%s", "Error sending request");
|
|
Line 6562: snprintf(ebuf, sizeof(ebuf), "Invalid URI: [%s]", ri->uri);
|
|
Line 6566: snprintf(ebuf, sizeof(ebuf), "Bad HTTP version: [%s]", ri->http_version);
|
|
GitHub\ceph\src\civetweb\src\main.c (16 hits)
|
|
Line 65: #define snprintf _snprintf
|
|
Line 65: #define snprintf _snprintf
|
|
Line 66: #define vsnprintf _vsnprintf
|
|
Line 66: #define vsnprintf _vsnprintf
|
|
Line 124: (void) vsnprintf(msg, sizeof(msg) -1, fmt, ap);
|
|
Line 187: snprintf(url, sizeof(url), "%s://%d.%d.%d.%d:%d",
|
|
Line 190: snprintf(url, sizeof(url), "%s://localhost:%d",
|
|
Line 193: snprintf(url, sizeof(url), "%s", "http://localhost:8080");
|
|
Line 358: snprintf(config_file, sizeof(config_file), "%s", argv[1]);
|
|
Line 362: snprintf(config_file, sizeof(config_file)-1, "%s", CONFIG_FILE);
|
|
Line 365: snprintf(config_file, sizeof(config_file)-1, "%.*s%c%s",
|
|
Line 411: snprintf(server_base_name, sizeof(server_base_name), "Civetweb V%s",
|
|
Line 504: snprintf(path, sizeof(path)-1, "%.*s", (int) (p - path_to_civetweb_exe),
|
|
Line 662: snprintf(value, sizeof(value)-1, "%s",
|
|
Line 1396: snprintf(buf, sizeof(buf)-1, "NT service: %s installed",
|
|
Line 1481: snprintf(TrayIcon.szTip, sizeof(TrayIcon.szTip), "%s", server_name);
|
|
GitHub\ceph\src\civetweb\src\mod_lua.inl (2 hits)
|
|
Line 276: snprintf(chunkname, sizeof(chunkname), "@%s+%i", path, lines);
|
|
Line 1129: len = vsnprintf(buf, sizeof(buf), fmt, ap);
|
|
GitHub\ceph\src\civetweb\src\third_party\sqlite3.c (126 hits)
|
|
Line 1641: ** log message after formatting via [sqlite3_snprintf()].
|
|
Line 2190: ** ^(The sqlite3_snprintf() routine is similar to "snprintf()" from
|
|
Line 2190: ** ^(The sqlite3_snprintf() routine is similar to "snprintf()" from
|
|
Line 2194: ** first two parameters is reversed from snprintf().)^ This is an
|
|
Line 2196: ** backwards compatibility. ^(Note also that sqlite3_snprintf()
|
|
Line 2200: ** value but we cannot change the implementation of sqlite3_snprintf()
|
|
Line 2203: ** ^As long as the buffer size is greater than zero, sqlite3_snprintf()
|
|
Line 2209: ** ^The sqlite3_vsnprintf() routine is a varargs version of sqlite3_snprintf().
|
|
Line 2209: ** ^The sqlite3_vsnprintf() routine is a varargs version of sqlite3_snprintf().
|
|
Line 2273: SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...);
|
|
Line 2274: SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list);
|
|
Line 3749: ** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns
|
|
Line 3758: ** [sqlite3_snprintf()] to convert that value to a UTF-16 string and returns
|
|
Line 3782: ** is requested, [sqlite3_snprintf()] is used internally to perform the
|
|
Line 6974: ** used with [sqlite3_snprintf()] to generate the final output string.
|
|
Line 14831: sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d %02d:%02d:%02d",
|
|
Line 14851: sqlite3_snprintf(sizeof(zBuf), zBuf, "%02d:%02d:%02d", x.h, x.m, (int)x.s);
|
|
Line 14870: sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d", x.Y, x.M, x.D);
|
|
Line 14965: case 'd': sqlite3_snprintf(3, &z[j],"%02d",x.D); j+=2; break;
|
|
Line 14969: sqlite3_snprintf(7, &z[j],"%06.3f", s);
|
|
Line 14973: case 'H': sqlite3_snprintf(3, &z[j],"%02d",x.h); j+=2; break;
|
|
Line 14986: sqlite3_snprintf(3, &z[j],"%02d",(nDay+7-wd)/7);
|
|
Line 14989: sqlite3_snprintf(4, &z[j],"%03d",nDay+1);
|
|
Line 14995: sqlite3_snprintf(20, &z[j],"%.16g",x.iJD/86400000.0);
|
|
Line 14999: case 'm': sqlite3_snprintf(3, &z[j],"%02d",x.M); j+=2; break;
|
|
Line 15000: case 'M': sqlite3_snprintf(3, &z[j],"%02d",x.m); j+=2; break;
|
|
Line 15002: sqlite3_snprintf(30,&z[j],"%lld",
|
|
Line 15007: case 'S': sqlite3_snprintf(3,&z[j],"%02d",(int)x.s); j+=2; break;
|
|
Line 15013: sqlite3_snprintf(5,&z[j],"%04d",x.Y); j+=sqlite3Strlen30(&z[j]);
|
|
Line 20474: ** sqlite3_snprintf() works like snprintf() except that it ignores the
|
|
Line 20474: ** sqlite3_snprintf() works like snprintf() except that it ignores the
|
|
Line 20479: ** Oops: The first two arguments of sqlite3_snprintf() are backwards
|
|
Line 20480: ** from the snprintf() standard. Unfortunately, it is too late to change
|
|
Line 20484: ** sqlite3_vsnprintf() is the varargs version.
|
|
Line 20486: SQLITE_API char *sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){
|
|
Line 20494: SQLITE_API char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){
|
|
Line 20498: z = sqlite3_vsnprintf(n, zBuf, zFormat, ap);
|
|
Line 26677: sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename);
|
|
Line 27392: sqlite3_snprintf(nShmFilename, zShmFilename,
|
|
Line 27396: sqlite3_snprintf(nShmFilename, zShmFilename, "%s-shm", pDbFd->zPath);
|
|
Line 28452: sqlite3_snprintf(nFilename, zLockFile, "%s" DOTLOCK_SUFFIX, zFilename);
|
|
Line 28467: sqlite3_snprintf(MAX_PATHNAME, zSemName, "/%s.sem",
|
|
Line 28561: sqlite3_snprintf(nBuf-18, zBuf, "%s/"SQLITE_TEMP_FILE_PREFIX, zDir);
|
|
Line 29099: sqlite3_snprintf(nOut, zOut, "%s", zPath);
|
|
Line 29106: sqlite3_snprintf(nOut-nCwd, &zOut[nCwd], "/%s", zPath);
|
|
Line 29136: sqlite3_snprintf(nBuf, zBufOut, "%s", zErr);
|
|
Line 29735: sqlite3_snprintf(sizeof(errmsg),errmsg,"path error (len %d)",(int)pathLen);
|
|
Line 29741: sqlite3_snprintf(sizeof(errmsg),errmsg,"read error (len %d)",(int)readLen);
|
|
Line 29747: sqlite3_snprintf(sizeof(errmsg), errmsg, "create failed (%d)", errno);
|
|
Line 29751: sqlite3_snprintf(sizeof(errmsg), errmsg, "write failed (%d)", errno);
|
|
Line 29755: sqlite3_snprintf(sizeof(errmsg), errmsg, "rename failed (%d)", errno);
|
|
Line 32439: sqlite3_snprintf(nBuf, zBuf, "OsError 0x%lx (%lu)", lastErrno, lastErrno);
|
|
Line 32442: sqlite3_snprintf(nBuf, zBuf, "%s", zOut);
|
|
Line 34103: sqlite3_snprintf(nName+15, pNew->zFilename, "%s-shm", pDbFd->zPath);
|
|
Line 34859: sqlite3_snprintf(nBuf-30, zBuf, "%s%s", sqlite3_temp_directory,
|
|
Line 34901: sqlite3_snprintf(nBuf-30, zBuf, "%s", zDir);
|
|
Line 34935: sqlite3_snprintf(nBuf-30, zBuf, "%s", zUtf8);
|
|
Line 34940: sqlite3_snprintf(nBuf-30, zBuf, "%s", zConverted);
|
|
Line 34967: sqlite3_snprintf(nBuf-30, zBuf, "%s", zMulti);
|
|
Line 34994: sqlite3_snprintf(nBuf-30, zBuf, "%s", zUtf8);
|
|
Line 35016: sqlite3_snprintf(nBuf-18-nLen, zBuf+nLen, SQLITE_TEMP_FILE_PREFIX);
|
|
Line 35616: sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%s%s",
|
|
Line 35639: sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%s%s",
|
|
Line 35642: sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zRelative);
|
|
Line 35672: sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%s%s",
|
|
Line 35733: sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zOut);
|
|
Line 39723: sqlite3_snprintf(1024, zRet,
|
|
Line 46697: sqlite3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]",
|
|
Line 57945: sqlite3_snprintf(sizeof(zContext), zContext, "Page %d: ", iPage);
|
|
Line 57980: sqlite3_snprintf(sizeof(zContext), zContext,
|
|
Line 58029: sqlite3_snprintf(sizeof(zContext), zContext,
|
|
Line 59458: ** are converted using sqlite3_snprintf(). Converting a BLOB to a string
|
|
Line 59490: ** FIX ME: It would be better if sqlite3_snprintf() could do UTF-16.
|
|
Line 59493: sqlite3_snprintf(nByte, pMem->z, "%lld", pMem->u.i);
|
|
Line 59496: sqlite3_snprintf(nByte, pMem->z, "%!.15g", pMem->r);
|
|
Line 61551: sqlite3_snprintf(nTemp, zTemp, "keyinfo(%d", pKeyInfo->nField);
|
|
Line 61575: sqlite3_snprintf(nTemp, zTemp, "collseq(%.20s)", pColl->zName);
|
|
Line 61580: sqlite3_snprintf(nTemp, zTemp, "%s(%d)", pDef->zName, pDef->nArg);
|
|
Line 61584: sqlite3_snprintf(nTemp, zTemp, "%lld", *pOp->p4.pI64);
|
|
Line 61588: sqlite3_snprintf(nTemp, zTemp, "%d", pOp->p4.i);
|
|
Line 61592: sqlite3_snprintf(nTemp, zTemp, "%.16g", *pOp->p4.pReal);
|
|
Line 61600: sqlite3_snprintf(nTemp, zTemp, "%lld", pMem->u.i);
|
|
Line 61602: sqlite3_snprintf(nTemp, zTemp, "%.16g", pMem->r);
|
|
Line 61604: sqlite3_snprintf(nTemp, zTemp, "NULL");
|
|
Line 61614: sqlite3_snprintf(nTemp, zTemp, "vtab:%p:%p", pVtab, pVtab->pModule);
|
|
Line 61619: sqlite3_snprintf(nTemp, zTemp, "intarray");
|
|
Line 61623: sqlite3_snprintf(nTemp, zTemp, "program");
|
|
Line 61972: sqlite3_snprintf(3, pMem->z, "%.2x", pOp->p5); /* P5 */
|
|
Line 62031: sqlite3_snprintf(sizeof(z), z, "%s", pOp->p4.z);
|
|
Line 62545: sqlite3_snprintf(13, &zMaster[nMainFile], "-mj%06X9%02X",
|
|
Line 65977: sqlite3_snprintf(100, zCsr, "%c", c);
|
|
Line 65979: sqlite3_snprintf(100, zCsr, "%d[", pMem->n);
|
|
Line 65982: sqlite3_snprintf(100, zCsr, "%02X", ((int)pMem->z[i] & 0xFF));
|
|
Line 65991: sqlite3_snprintf(100, zCsr, "]%s", encnames[pMem->enc]);
|
|
Line 65994: sqlite3_snprintf(100, zCsr,"+%dz",pMem->u.nZero);
|
|
Line 66014: sqlite3_snprintf(100, &zBuf[k], "%d", pMem->n);
|
|
Line 66026: sqlite3_snprintf(100,&zBuf[k], encnames[pMem->enc]);
|
|
Line 82037: sqlite3_snprintf(24, zRet, "%llu", (u64)p->nRow);
|
|
Line 82042: sqlite3_snprintf(24, z, " %llu", iVal);
|
|
Line 82083: sqlite3_snprintf(24, z, "%llu ", (u64)aCnt[i]);
|
|
Line 83207: sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
|
|
Line 83211: sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
|
|
Line 83215: sqlite3_snprintf(sizeof(zErr), zErr,
|
|
Line 83220: sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
|
|
Line 85233: sqlite3_snprintf(n, zStmt, "CREATE TABLE ");
|
|
Line 85248: sqlite3_snprintf(n-k, &zStmt[k], zSep);
|
|
Line 85268: sqlite3_snprintf(n-k, &zStmt[k], "%s", zEnd);
|
|
Line 85854: sqlite3_snprintf(sizeof(zTab),zTab,"sqlite_stat%d",i);
|
|
Line 89711: sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.15g", r1);
|
|
Line 89714: sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.20e", r1);
|
|
Line 94068: char * (*snprintf)(int,char*,const char*,...);
|
|
Line 94180: char *(*vsnprintf)(int,char*,const char*,va_list);
|
|
Line 94298: #define sqlite3_snprintf sqlite3_api->snprintf
|
|
Line 94298: #define sqlite3_snprintf sqlite3_api->snprintf
|
|
Line 94397: #define sqlite3_uri_vsnprintf sqlite3_api->vsnprintf
|
|
Line 94397: #define sqlite3_uri_vsnprintf sqlite3_api->vsnprintf
|
|
Line 94631: sqlite3_snprintf,
|
|
Line 94791: sqlite3_vsnprintf,
|
|
Line 94865: sqlite3_snprintf(nMsg, zErrmsg,
|
|
Line 94913: sqlite3_snprintf(nMsg, zErrmsg,
|
|
Line 118618: sqlite3_snprintf(sizeof(zBuf), zBuf, "SQLITE_UNKNOWN(%d)", origRc);
|
|
Line 138642: sqlite3_snprintf(sizeof(aBuffer), aBuffer,
|
|
Line 142697: sqlite3_snprintf(512-nCell,&zCell[nCell],"%lld", cell.iRowid);
|
|
Line 142701: sqlite3_snprintf(512-nCell,&zCell[nCell], " %f",
|
|
Line 142704: sqlite3_snprintf(512-nCell,&zCell[nCell], " %d",
|
|
Line 143057: sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e));
|
|
GitHub\ceph\src\civetweb\src\third_party\sqlite3.h (15 hits)
|
|
Line 1613: ** log message after formatting via [sqlite3_snprintf()].
|
|
Line 2162: ** ^(The sqlite3_snprintf() routine is similar to "snprintf()" from
|
|
Line 2162: ** ^(The sqlite3_snprintf() routine is similar to "snprintf()" from
|
|
Line 2166: ** first two parameters is reversed from snprintf().)^ This is an
|
|
Line 2168: ** backwards compatibility. ^(Note also that sqlite3_snprintf()
|
|
Line 2172: ** value but we cannot change the implementation of sqlite3_snprintf()
|
|
Line 2175: ** ^As long as the buffer size is greater than zero, sqlite3_snprintf()
|
|
Line 2181: ** ^The sqlite3_vsnprintf() routine is a varargs version of sqlite3_snprintf().
|
|
Line 2181: ** ^The sqlite3_vsnprintf() routine is a varargs version of sqlite3_snprintf().
|
|
Line 2245: SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...);
|
|
Line 2246: SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list);
|
|
Line 3721: ** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns
|
|
Line 3730: ** [sqlite3_snprintf()] to convert that value to a UTF-16 string and returns
|
|
Line 3754: ** is requested, [sqlite3_snprintf()] is used internally to perform the
|
|
Line 6946: ** used with [sqlite3_snprintf()] to generate the final output string.
|
|
GitHub\ceph\src\civetweb\test\unit_test.c (1 hit)
|
|
Line 579: snprintf(buf, sizeof(buf), "%s = %s", var_name, expr);
|
|
GitHub\ceph\src\client\Client.cc (21 hits)
|
|
Line 7068: snprintf(oid_buf, sizeof(oid_buf), "%llx.00000000", (long long unsigned)in->ino);
|
|
Line 8976: return snprintf(val, size,
|
|
Line 8983: return snprintf(val, size, "%lld", (long long int)in->quota.max_bytes);
|
|
Line 8987: return snprintf(val, size, "%lld", (long long int)in->quota.max_files);
|
|
Line 9000: int r = snprintf(val, size,
|
|
Line 9007: r += snprintf(val + r, size - r, "%s",
|
|
Line 9010: r += snprintf(val + r, size - r, "%lld",
|
|
Line 9017: return snprintf(val, size, "%lld", (unsigned long long)in->layout.fl_stripe_unit);
|
|
Line 9021: return snprintf(val, size, "%lld", (unsigned long long)in->layout.fl_stripe_count);
|
|
Line 9025: return snprintf(val, size, "%lld", (unsigned long long)in->layout.fl_object_size);
|
|
Line 9032: r = snprintf(val, size, "%s", osdmap->get_pool_name(in->layout.fl_pg_pool).c_str());
|
|
Line 9034: r = snprintf(val, size, "%lld", (unsigned long long)in->layout.fl_pg_pool);
|
|
Line 9040: return snprintf(val, size, "%lld", (unsigned long long)(in->dirstat.nfiles + in->dirstat.nsubdirs));
|
|
Line 9044: return snprintf(val, size, "%lld", (unsigned long long)in->dirstat.nfiles);
|
|
Line 9048: return snprintf(val, size, "%lld", (unsigned long long)in->dirstat.nsubdirs);
|
|
Line 9052: return snprintf(val, size, "%lld", (unsigned long long)(in->rstat.rfiles + in->rstat.rsubdirs));
|
|
Line 9056: return snprintf(val, size, "%lld", (unsigned long long)in->rstat.rfiles);
|
|
Line 9060: return snprintf(val, size, "%lld", (unsigned long long)in->rstat.rsubdirs);
|
|
Line 9064: return snprintf(val, size, "%lld", (unsigned long long)in->rstat.rbytes);
|
|
Line 9068: return snprintf(val, size, "%ld.09%ld", (long)in->rstat.rctime.sec(),
|
|
Line 10931: snprintf(oid_buf, sizeof(oid_buf), "%llx.00000000", (unsigned long long)in->ino);
|
|
GitHub\ceph\src\client\fuse_ll.cc (1 hit)
|
|
Line 766: snprintf(cmd, sizeof(cmd), "mount -i -o remount %s", cfuse->mountpoint);
|
|
GitHub\ceph\src\client\SyntheticClient.cc (38 hits)
|
|
Line 300: snprintf(s, sizeof(s), "syn.%lld.%d", (long long)client->whoami.v, seq);
|
|
Line 778: snprintf(realtfile, sizeof(realtfile), tfile.c_str(), (int)client->get_nodeid().v);
|
|
Line 1748: snprintf(d, sizeof(d), "%s/file.%d", basedir, i);
|
|
Line 1755: snprintf(d, sizeof(d), "%s/dir.%d", basedir, i);
|
|
Line 1778: snprintf(d, sizeof(d), "%s/file.%d", basedir, i);
|
|
Line 1785: snprintf(d, sizeof(d), "%s/dir.%d", basedir, i);
|
|
Line 1812: snprintf(d, sizeof(d), "%s/file.%d", basedir, i);
|
|
Line 1824: snprintf(d, sizeof(d), "%s/dir.%d", basedir, i);
|
|
Line 1839: snprintf(d, sizeof(d), "dir.%d.run%d", whoami, c);
|
|
Line 1846: snprintf(d, sizeof(d), "dir.%d.run%d", 0, c);
|
|
Line 1859: snprintf(d, sizeof(d), "dir.%d.run%d/file.client%d.%d", priv ? whoami:0, c, whoami, n);
|
|
Line 1893: snprintf(d, sizeof(d), "orig/file.%d", i);
|
|
Line 1904: snprintf(d, sizeof(d), "orig/file.%d", i);
|
|
Line 1905: snprintf(e, sizeof(e), "copy/file.%d", i);
|
|
Line 1922: snprintf(d, sizeof(d), "test/file.%d", n);
|
|
Line 1937: snprintf(d, sizeof(d), "test/file.%d", n);
|
|
Line 1944: snprintf(d, sizeof(d), "test/file.%d", n);
|
|
Line 2948: snprintf(a, sizeof(a), "/a/%d", i);
|
|
Line 2953: snprintf(a, sizeof(a), "/a/%d", i);
|
|
Line 2954: snprintf(b, sizeof(b), "/b/%d", i);
|
|
Line 2958: snprintf(b, sizeof(b), "/b/%d", i);
|
|
Line 3007: snprintf(src, sizeof(src), "syn.0.0/dir.%d/dir.%d/file.%d", a, b, c);
|
|
Line 3027: snprintf(src, sizeof(src), "syn.0.0/dir.%d/dir.%d/file.%d", a, b, c);
|
|
Line 3028: snprintf(dst, sizeof(dst), "syn.0.0/dir.%d/dir.%d/file.%d", d, e, f);
|
|
Line 3047: snprintf(src, sizeof(src), "syn.0.0/dir.%d/dir.%d/file.%d", a, b, c);
|
|
Line 3048: snprintf(dst, sizeof(dst), "syn.0.0/dir.%d/dir.%d/newlink.%d", d, e, f);
|
|
Line 3062: snprintf(src, sizeof(src), "syn.0.0/dir.%d/dir.%d/file.%d", a, b, c);
|
|
Line 3063: snprintf(dst, sizeof(dst), "syn.0.0/dir.%d/dir.%d/newlink.%d", d, e, f);
|
|
Line 3150: snprintf(t, sizeof(t), "/dir.%d", a);
|
|
Line 3159: snprintf(t, sizeof(t), "/dir.%d", a);
|
|
Line 3177: snprintf(t, sizeof(t), "/dir.%d", a);
|
|
Line 3181: snprintf(t, sizeof(t), "/file.%d", a);
|
|
Line 3189: snprintf(t, sizeof(t), "/dir.%d", a);
|
|
Line 3193: snprintf(t, sizeof(t), "/file.%d", a);
|
|
Line 3230: snprintf(f, sizeof(f), "/dir.%d", rand() % dirs);
|
|
Line 3234: snprintf(f, sizeof(f), "/file.%d", rand() % files);
|
|
Line 3242: snprintf(f, sizeof(f), "/dir.%d", rand() % dirs);
|
|
Line 3246: snprintf(f, sizeof(f), "/ln.%d", i);
|
|
GitHub\ceph\src\client\SyntheticClient.h (1 hit)
|
|
Line 163: snprintf(sub_s, sizeof(sub_s), "%s.%d", base, rand() % 100);
|
|
GitHub\ceph\src\client\test_ioctls.c (1 hit)
|
|
Line 107: snprintf(new_file_name, sizeof(new_file_name),
|
|
GitHub\ceph\src\cls\log\cls_log.cc (1 hit)
|
|
Line 46: snprintf(buf, sizeof(buf), "%010ld.%06ld_", (long)ts.sec(), (long)ts.usec());
|
|
GitHub\ceph\src\cls\rgw\cls_rgw.cc (12 hits)
|
|
Line 117: snprintf(buf, 32, "%011llu.%09u", (unsigned long long)ut.sec(), ut.nsec());
|
|
Line 124: snprintf(buf, sizeof(buf), "%011llu.%llu.%d", (unsigned long long)index_ver,
|
|
Line 231: snprintf(buf, sizeof(buf), "9%02lld", 15 - (long long)num);
|
|
Line 233: snprintf(buf, sizeof(buf), "8%03lld", 255 - (long long)num);
|
|
Line 235: snprintf(buf, sizeof(buf), "7%04lld", 4095 - (long long)num);
|
|
Line 237: snprintf(buf, sizeof(buf), "6%05lld", 65535 - (long long)num);
|
|
Line 239: snprintf(buf, sizeof(buf), "5%010lld", 0xFFFFFFFF - (long long)num);
|
|
Line 241: snprintf(buf, sizeof(buf), "4%020lld", (long long)-num);
|
|
Line 2454: snprintf(buf, sizeof(buf), "%011llu", (long long unsigned)epoch);
|
|
Line 2461: snprintf(buf, sizeof(buf), "%s_%011llu_", user.c_str(), (long long unsigned)epoch);
|
|
Line 2468: snprintf(buf, sizeof(buf), "%011llu_%s_%s", (long long unsigned)epoch, user.c_str(), bucket.c_str());
|
|
Line 2475: snprintf(buf, sizeof(buf), "%s_%011llu_%s", user.c_str(), (long long unsigned)epoch, bucket.c_str());
|
|
GitHub\ceph\src\cls\rgw\cls_rgw_client.h (1 hit)
|
|
Line 164: snprintf(buf, sizeof(buf), "%d", iter->first);
|
|
GitHub\ceph\src\cls\statelog\cls_statelog.cc (1 hit)
|
|
Line 58: snprintf(buf, sizeof(buf), "%d_", (int)object.size());
|
|
GitHub\ceph\src\cls\user\cls_user_types.cc (1 hit)
|
|
Line 11: snprintf(buf, sizeof(buf), ".%d", i);
|
|
GitHub\ceph\src\cls\user\cls_user_types.h (1 hit)
|
|
Line 42: snprintf(buf, sizeof(buf), "%llu", (long long)id);
|
|
GitHub\ceph\src\common\admin_socket.cc (1 hit)
|
|
Line 210: snprintf(address.sun_path, sizeof(address.sun_path),
|
|
GitHub\ceph\src\common\admin_socket_client.cc (2 hits)
|
|
Line 53: snprintf(buf, sizeof(((struct sockaddr_un*)0)->sun_path),
|
|
Line 74: snprintf(address.sun_path, sizeof(address.sun_path), "%s", path.c_str());
|
|
GitHub\ceph\src\common\assert.cc (3 hits)
|
|
Line 53: snprintf(buf, sizeof(buf),
|
|
Line 98: int n = vsnprintf(bufptr, remaining, format, args);
|
|
Line 153: snprintf(buf, sizeof(buf),
|
|
GitHub\ceph\src\common\blkdev.cc (4 hits)
|
|
Line 66: snprintf(fn, sizeof(fn), "%s/sys/block/%s", sandbox_dir, devname);
|
|
Line 75: snprintf(fn, sizeof(fn), "%s/sys/block", sandbox_dir);
|
|
Line 90: snprintf(fn, sizeof(fn), "%s/sys/block/%s/%s", sandbox_dir, de->d_name,
|
|
Line 126: snprintf(filename, sizeof(filename),
|
|
GitHub\ceph\src\common\config.cc (2 hits)
|
|
Line 793: snprintf(*buf, len, "%s", str.c_str());
|
|
Line 805: int l = snprintf(*buf, len, "%d/%d", subsys.get_log_level(o), subsys.get_gather_level(o));
|
|
GitHub\ceph\src\common\escape.c (2 hits)
|
|
Line 107: snprintf(o, 7, "&#x%02x;", c);
|
|
Line 200: snprintf(o, 7, "\\u%04x", c);
|
|
GitHub\ceph\src\common\fd.cc (1 hit)
|
|
Line 42: snprintf(path, sizeof(path), "%s/%s", fn, de.d_name);
|
|
GitHub\ceph\src\common\Formatter.cc (4 hits)
|
|
Line 268: snprintf(foo, sizeof(foo), "%lf", d);
|
|
Line 288: vsnprintf(buf, LARGE_SIZE, fmt, ap);
|
|
Line 438: vsnprintf(buf, LARGE_SIZE, fmt, ap);
|
|
Line 808: vsnprintf(buf, LARGE_SIZE, fmt, ap);
|
|
GitHub\ceph\src\common\hex.cc (3 hits)
|
|
Line 26: pos += snprintf(&buf[pos], dest_len-pos, " ");
|
|
Line 28: pos += snprintf(&buf[pos], dest_len-pos, "\n");
|
|
Line 29: pos += snprintf(&buf[pos], dest_len-pos, "%.2x ", (int)(unsigned char)s[i]);
|
|
GitHub\ceph\src\common\hobject.cc (7 hits)
|
|
Line 58: t += snprintf(t, sizeof(buf), "%.*llX", 16, (long long unsigned)poolid);
|
|
Line 66: snprintf(buf, sizeof(buf), "%.*X", (int)(sizeof(revhash))*2, revhash);
|
|
Line 81: t += snprintf(t, end - t, "%.*llX", 16, (long long unsigned)poolid);
|
|
Line 84: t += snprintf(t, end - t, ".%.*X", 8, revhash);
|
|
Line 87: t += snprintf(t, end - t, ".head");
|
|
Line 89: t += snprintf(t, end - t, ".snapdir");
|
|
Line 91: t += snprintf(t, end - t, ".%llx", (long long unsigned)snap);
|
|
GitHub\ceph\src\common\mime.c (3 hits)
|
|
Line 32: snprintf(o, outlen, "=%02X", c);
|
|
Line 42: snprintf(o, outlen, "%c", c);
|
|
Line 126: snprintf(o, outlen, "%c", c);
|
|
GitHub\ceph\src\common\module.c (2 hits)
|
|
Line 60: snprintf(command, sizeof(command),
|
|
Line 71: snprintf(command, sizeof(command), "/sbin/modprobe %s %s",
|
|
GitHub\ceph\src\common\obj_bencher.cc (6 hits)
|
|
Line 336: snprintf(data.object_contents, data.object_size, "I'm the %16dth object!", i);
|
|
Line 393: snprintf(newContents->c_str(), data.object_size, "I'm the %16dth object!", data.started);
|
|
Line 627: snprintf(data.object_contents, data.object_size, "I'm the %16dth object!", current_index);
|
|
Line 660: snprintf(data.object_contents, data.object_size, "I'm the %16dth object!", index[slot]);
|
|
Line 830: snprintf(data.object_contents, data.object_size, "I'm the %16dth object!", current_index);
|
|
Line 862: snprintf(data.object_contents, data.object_size, "I'm the %16dth object!", index[slot]);
|
|
GitHub\ceph\src\common\OutputDataSocket.cc (1 hit)
|
|
Line 180: snprintf(address.sun_path, sizeof(address.sun_path),
|
|
GitHub\ceph\src\common\safe_io.c (3 hits)
|
|
Line 169: snprintf(fn, sizeof(fn), "%s/%s", base, file);
|
|
Line 170: snprintf(tmp, sizeof(tmp), "%s/%s.tmp", base, file);
|
|
Line 214: snprintf(fn, sizeof(fn), "%s/%s", base, file);
|
|
GitHub\ceph\src\common\secret.c (2 hits)
|
|
Line 112: snprintf(option, olen, "secret=%s", secret);
|
|
Line 126: snprintf(option, olen, "key=%s", key_name);
|
|
GitHub\ceph\src\common\Thread.cc (1 hit)
|
|
Line 149: snprintf(buf, sizeof(buf), "Thread::try_create(): pthread_create "
|
|
GitHub\ceph\src\common\TrackedOp.h (1 hit)
|
|
Line 87: snprintf(lock_name, sizeof(lock_name), "%s:%d", "OpTracker::ShardedLock", i);
|
|
GitHub\ceph\src\crush\CrushCompiler.cc (1 hit)
|
|
Line 55: snprintf(s, sizeof(s), "%.3f", (float)i / (float)0x10000);
|
|
GitHub\ceph\src\crush\CrushWrapper.cc (1 hit)
|
|
Line 1307: snprintf(str, sizeof(str), "unsupported bucket algorithm: %d", alg);
|
|
GitHub\ceph\src\erasure-code\isa\ErasureCodeIsa.cc (2 hits)
|
|
Line 264: snprintf(id, sizeof (id), "+%d", r);
|
|
Line 270: snprintf(id, sizeof (id), "-%d", erasures[p]);
|
|
GitHub\ceph\src\global\global_init.cc (1 hit)
|
|
Line 50: snprintf(buf, sizeof(buf), "%s, process %s, pid %d",
|
|
GitHub\ceph\src\global\pidfile.cc (2 hits)
|
|
Line 43: snprintf(pid_file, PATH_MAX, "%s", conf->pid_file.c_str());
|
|
Line 55: int len = snprintf(buf, sizeof(buf), "%d\n", getpid());
|
|
GitHub\ceph\src\global\signal_handler.cc (4 hits)
|
|
Line 43: snprintf(buf, sizeof(buf), "install_sighandler: sigaction returned "
|
|
Line 64: snprintf(buf, sizeof(buf), "reraise_fatal: failed to re-raise "
|
|
Line 69: snprintf(buf, sizeof(buf), "reraise_fatal: default handler for "
|
|
Line 82: snprintf(buf, sizeof(buf), "*** Caught signal (%s) **\n "
|
|
GitHub\ceph\src\gmock\gtest\include\gtest\internal\gtest-port.h (13 hits)
|
|
Line 1821: // MSVC "deprecates" snprintf and issues warnings wherever it is used. In
|
|
Line 1822: // order to avoid these warnings, we need to use _snprintf or _snprintf_s on
|
|
Line 1822: // order to avoid these warnings, we need to use _snprintf or _snprintf_s on
|
|
Line 1823: // MSVC-based platforms. We map the GTEST_SNPRINTF_ macro to the appropriate
|
|
Line 1825: // snprintf is a variadic function.
|
|
Line 1828: # define GTEST_SNPRINTF_(buffer, size, format, ...) \
|
|
Line 1829: _snprintf_s(buffer, size, size, format, __VA_ARGS__)
|
|
Line 1831: // Windows CE does not define _snprintf_s and MSVC prior to 2005 doesn't
|
|
Line 1832: // complain about _snprintf.
|
|
Line 1833: # define GTEST_SNPRINTF_ _snprintf
|
|
Line 1833: # define GTEST_SNPRINTF_ _snprintf
|
|
Line 1835: # define GTEST_SNPRINTF_ snprintf
|
|
Line 1835: # define GTEST_SNPRINTF_ snprintf
|
|
GitHub\ceph\src\gmock\gtest\src\gtest-port.cc (2 hits)
|
|
Line 178: snprintf(full_pattern, full_regex_len, "^(%s)$", regex);
|
|
Line 439: // We don't use snprintf or strncpy, as they trigger a warning when
|
|
GitHub\ceph\src\gmock\gtest\src\gtest-printers.cc (1 hit)
|
|
Line 72: GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]);
|
|
GitHub\ceph\src\gmock\gtest\src\gtest.cc (3 hits)
|
|
Line 62: // Declares vsnprintf(). This header is not available on Windows.
|
|
Line 139: # define vsnprintf _vsnprintf
|
|
Line 139: # define vsnprintf _vsnprintf
|
|
GitHub\ceph\src\include\buffer.h (1 hit)
|
|
Line 90: snprintf(buf, sizeof(buf), "buffer::malformed_input: %s", w.c_str());
|
|
GitHub\ceph\src\include\CompatSet.h (1 hit)
|
|
Line 115: snprintf(s, sizeof(s), "feature_%lld", (unsigned long long)p->first);
|
|
GitHub\ceph\src\include\encoding.h (1 hit)
|
|
Line 132: snprintf(fn, sizeof(fn), ENCODE_STRINGIFY(ENCODE_DUMP) "/%s__%d.%x", #cl, getpid(), i++); \
|
|
GitHub\ceph\src\include\utime.h (1 hit)
|
|
Line 241: return snprintf(out, outlen,
|
|
GitHub\ceph\src\librbd\ImageCtx.cc (3 hits)
|
|
Line 260: snprintf(format_string, len, "%s.%%012llx", object_prefix.c_str());
|
|
Line 262: snprintf(format_string, len, "%s.%%016llx", object_prefix.c_str());
|
|
Line 403: snprintf(buf, sizeof(buf), format_string, num);
|
|
GitHub\ceph\src\librbd\internal.cc (1 hit)
|
|
Line 362: snprintf(ondisk.block_name, sizeof(ondisk.block_name), "rb.%x.%x.%x",
|
|
GitHub\ceph\src\libs3\inc\string_buffer.h (2 hits)
|
|
Line 51: sb##Len += snprintf(&(sb[sb##Len]), sizeof(sb) - sb##Len - 1, \
|
|
Line 84: smb##Size += (snprintf(&(smb[smb##Size]), \
|
|
GitHub\ceph\src\libs3\src\acl.c (1 hit)
|
|
Line 167: *xmlDocumentLenReturn += snprintf \
|
|
GitHub\ceph\src\libs3\src\bucket.c (4 hits)
|
|
Line 95: snprintf(tbData->locationConstraintReturn,
|
|
Line 248: snprintf(cbData->doc, sizeof(cbData->doc),
|
|
Line 538: snprintf(lbData->commonPrefixes[which],
|
|
Line 688: snprintf(maxKeysString, sizeof(maxKeysString), "%d", maxkeys);
|
|
GitHub\ceph\src\libs3\src\general.c (2 hits)
|
|
Line 285: snprintf(&(caData->ownerId[caData->ownerIdLen]),
|
|
Line 295: snprintf(&(caData->ownerDisplayName
|
|
GitHub\ceph\src\libs3\src\object.c (1 hit)
|
|
Line 108: snprintf(&(coData->eTagReturn[coData->eTagReturnLen]),
|
|
GitHub\ceph\src\libs3\src\request.c (14 hits)
|
|
Line 267: len += snprintf(&(values->amzHeadersRaw[len]), \
|
|
Line 304: int l = snprintf(headerName, sizeof(headerName),
|
|
Line 377: int len = snprintf(values-> destField, \
|
|
Line 407: int len = snprintf(values-> destField, \
|
|
Line 492: snprintf(values->rangeHeader, sizeof(values->rangeHeader),
|
|
Line 499: snprintf(values->rangeHeader, sizeof(values->rangeHeader),
|
|
Line 701: len += snprintf(&(signbuf[len]), sizeof(signbuf) - len, \
|
|
Line 733: snprintf(values->authorizationHeader, sizeof(values->authorizationHeader),
|
|
Line 751: len += snprintf(&(buffer[len]), bufferSize - len, fmt, __VA_ARGS__); \
|
|
Line 880: snprintf(header, sizeof(header), "Content-Length: %llu",
|
|
Line 1079: if (snprintf(defaultHostNameG, S3_MAX_HOSTNAME_SIZE,
|
|
Line 1100: snprintf(platform, sizeof(platform), "%s%s%s", utsn.sysname,
|
|
Line 1104: snprintf(userAgentG, sizeof(userAgentG),
|
|
Line 1357: len += snprintf(&(signbuf[len]), sizeof(signbuf) - len, \
|
|
GitHub\ceph\src\libs3\src\s3.c (11 hits)
|
|
Line 510: snprintf(putenvBufG, sizeof(putenvBufG), "TZ=UTC");
|
|
Line 515: snprintf(putenvBufG, sizeof(putenvBufG), "TZ=%s", tz ? tz : "");
|
|
Line 766: len += snprintf(&(errorDetailsG[len]), sizeof(errorDetailsG) - len,
|
|
Line 770: len += snprintf(&(errorDetailsG[len]), sizeof(errorDetailsG) - len,
|
|
Line 774: len += snprintf(&(errorDetailsG[len]), sizeof(errorDetailsG) - len,
|
|
Line 778: len += snprintf(&(errorDetailsG[len]), sizeof(errorDetailsG) - len,
|
|
Line 782: len += snprintf(&(errorDetailsG[len]),
|
|
Line 1115: snprintf(data->nextMarker, sizeof(data->nextMarker), "%s",
|
|
Line 1218: snprintf(data.nextMarker, sizeof(data.nextMarker), "%s", marker);
|
|
Line 2247: snprintf(composedId, sizeof(composedId),
|
|
Line 2507: snprintf(composedId, sizeof(composedId),
|
|
GitHub\ceph\src\libs3\src\service_access_logging.c (3 hits)
|
|
Line 64: snprintf(&(caData->targetBucketReturn
|
|
Line 75: snprintf(&(caData->targetPrefixReturn
|
|
Line 369: *xmlDocumentLenReturn += snprintf \
|
|
GitHub\ceph\src\log\Log.cc (3 hits)
|
|
Line 221: buflen += snprintf(buf, sizeof(buf), "%6d> ", -t->m_len);
|
|
Line 223: buflen += snprintf(buf + buflen, sizeof(buf)-buflen, " %lx %2d ",
|
|
Line 294: snprintf(buf, sizeof(buf), " %2d/%2d %s", p->log_level, p->gather_level, p->name.c_str());
|
|
GitHub\ceph\src\mds\CInode.cc (4 hits)
|
|
Line 805: snprintf(t, sizeof(t), "~mds%" PRId64, eino);
|
|
Line 811: snprintf(n, sizeof(n), "#%" PRIx64, eino);
|
|
Line 846: snprintf(s, sizeof(s), "%llx", (unsigned long long)inode.ino.val);
|
|
Line 937: snprintf(n, sizeof(n), "%llx.%08llx%s", (long long unsigned)ino, (long long unsigned)fg, suffix ? suffix : "");
|
|
GitHub\ceph\src\mds\JournalPointer.cc (1 hit)
|
|
Line 34: snprintf(buf, sizeof(buf), "%llx.%08llx", (long long unsigned)pointer_ino, (long long unsigned)0);
|
|
GitHub\ceph\src\mds\MDCache.cc (4 hits)
|
|
Line 431: snprintf(myname, sizeof(myname), "mds%d", int(mds->whoami));
|
|
Line 11425: snprintf(s, sizeof(s), "%2d ", int(dir->get_dir_auth().first));
|
|
Line 11427: snprintf(s, sizeof(s), "%2d,%2d", int(dir->get_dir_auth().first), int(dir->get_dir_auth().second));
|
|
Line 11522: snprintf(deffn, sizeof(deffn), "cachedump.%d.mds%d", (int)mds->mdsmap->get_epoch(), int(mds->get_nodeid()));
|
|
GitHub\ceph\src\mds\MDSTable.cc (2 hits)
|
|
Line 137: snprintf(n, sizeof(n), "mds%d_%s", int(mds->whoami), table_name);
|
|
Line 139: snprintf(n, sizeof(n), "mds_%s", table_name);
|
|
GitHub\ceph\src\mds\mdstypes.h (2 hits)
|
|
Line 675: snprintf(b, sizeof(b), "%" PRIx64, val);
|
|
Line 677: snprintf(b, sizeof(b), "%s", "head");
|
|
GitHub\ceph\src\mds\SessionMap.cc (1 hit)
|
|
Line 66: snprintf(s, sizeof(s), "mds%d_sessionmap", int(mds->whoami));
|
|
GitHub\ceph\src\mds\snap.cc (1 hit)
|
|
Line 73: snprintf(nm, sizeof(nm), "_%s_%llu", name.c_str(), (unsigned long long)ino);
|
|
GitHub\ceph\src\messages\MGenericMessage.h (1 hit)
|
|
Line 27: snprintf(tname, sizeof(tname), "generic%d", get_type());
|
|
GitHub\ceph\src\mon\OSDMonitor.cc (3 hits)
|
|
Line 555: snprintf(buf, sizeof(buf), "average %04f, overload %04f. ",
|
|
Line 580: snprintf(buf, sizeof(buf), "osd.%d [%04f -> %04f]", p->first,
|
|
Line 596: snprintf(buf, sizeof(buf), "osd.%d [%04f -> %04f]", p->first,
|
|
GitHub\ceph\src\mon\PGMap.cc (3 hits)
|
|
Line 1033: snprintf(b, sizeof(b), "%.3lf", pc);
|
|
Line 1049: snprintf(b, sizeof(b), "%.3lf", pc);
|
|
Line 1065: snprintf(b, sizeof(b), "%.3lf", pc);
|
|
GitHub\ceph\src\mount\canonicalize.c (2 hits)
|
|
Line 159: snprintf(path, sizeof(path), "/sys/block/%s/dm/name", ptname);
|
|
Line 166: snprintf(path, sizeof(path), "/dev/mapper/%s", name);
|
|
GitHub\ceph\src\mount\mtab.c (1 hit)
|
|
Line 153: snprintf(linktargetfile, sizeof(linktargetfile), MOUNTLOCK_LINKTARGET,
|
|
GitHub\ceph\src\msg\Message.cc (1 hit)
|
|
Line 230: snprintf(fn, sizeof(fn), ENCODE_STRINGIFY(ENCODE_DUMP) "/%s__%d.%x",
|
|
GitHub\ceph\src\msg\xio\XioMessenger.cc (1 hit)
|
|
Line 89: int n = vsnprintf(buffer, sizeof(buffer), fmt, args);
|
|
GitHub\ceph\src\objclass\class_api.cc (2 hits)
|
|
Line 604: snprintf(buf, sizeof(buf), "%lld.%d", (long long)ver, subop_num);
|
|
Line 616: int n = vsnprintf(buf, size, format, ap);
|
|
GitHub\ceph\src\os\BtrfsFileStoreBackend.cc (3 hits)
|
|
Line 329: snprintf(path, sizeof(path), "%s/%s", get_basedir_path().c_str(), de->d_name);
|
|
Line 439: snprintf(s, sizeof(s), "%s/current.remove.me.%d", get_basedir_path().c_str(), rand());
|
|
Line 448: snprintf(s, sizeof(s), "%s/%s", get_basedir_path().c_str(), name.c_str());
|
|
GitHub\ceph\src\os\chain_xattr.cc (1 hit)
|
|
Line 65: int r = snprintf(raw_name, raw_len - pos, "@%d", i);
|
|
GitHub\ceph\src\os\DBObjectMap.cc (9 hits)
|
|
Line 126: t += snprintf(t, end - t, "head");
|
|
Line 128: t += snprintf(t, end - t, "snapdir");
|
|
Line 130: t += snprintf(t, end - t, "%llx", (long long unsigned)oid.hobj.snap);
|
|
Line 133: t += snprintf(t, end - t, ".none");
|
|
Line 135: t += snprintf(t, end - t, ".%llx", (long long unsigned)oid.hobj.pool);
|
|
Line 136: t += snprintf(t, end - t, ".%.*X", (int)(sizeof(uint32_t)*2), oid.hobj.get_hash());
|
|
Line 140: t += snprintf(t, end - t, ".%llx", (long long unsigned)oid.generation);
|
|
Line 141: t += snprintf(t, end - t, ".%x", (int)oid.shard_id);
|
|
Line 198: snprintf(buf, sizeof(buf), "%.*" PRId64, (int)(2*sizeof(seq)), seq);
|
|
GitHub\ceph\src\os\FileStore.cc (17 hits)
|
|
Line 151: return snprintf(s, len, "%s/current/%s", basedir.c_str(), cid_str.c_str());
|
|
Line 626: snprintf(buf, len, "user.ceph.%s", name);
|
|
Line 743: snprintf(fsid_fn, sizeof(fsid_fn), "%s/fsid", basedir.c_str());
|
|
Line 854: snprintf(s, sizeof(s), COMMIT_SNAP_ITEM, 1ull);
|
|
Line 897: snprintf(fn, sizeof(fn), "%s/fsid", basedir.c_str());
|
|
Line 973: snprintf(fn, sizeof(fn), "%s/fsid", basedir.c_str());
|
|
Line 1007: snprintf(fn, sizeof(fn), "%s/xattr_test", basedir.c_str());
|
|
Line 1216: snprintf(s, sizeof(s), "%" PRId64 "\n", seq);
|
|
Line 1244: snprintf(buf, sizeof(buf), "%s/fsid", basedir.c_str());
|
|
Line 1354: snprintf(nosnapfn, sizeof(nosnapfn), "%s/nosnap", current_fn.c_str());
|
|
Line 1369: snprintf(s, sizeof(s), CLUSTER_SNAP_ITEM, m_osd_rollback_to_cluster_snap.c_str());
|
|
Line 1405: snprintf(s, sizeof(s), COMMIT_SNAP_ITEM, (long long unsigned)cp);
|
|
Line 3601: snprintf(s, sizeof(s), COMMIT_SNAP_ITEM, (long long unsigned)cp);
|
|
Line 3665: snprintf(s, sizeof(s), COMMIT_SNAP_ITEM, (long long unsigned)snaps.front());
|
|
Line 3811: snprintf(s, sizeof(s), CLUSTER_SNAP_ITEM, name.c_str());
|
|
Line 4477: snprintf(fn, sizeof(fn), "%s/current", basedir.c_str());
|
|
Line 4497: snprintf(filename, sizeof(filename), "%s/%s", fn, de->d_name);
|
|
GitHub\ceph\src\os\FlatIndex.cc (5 hits)
|
|
Line 124: snprintf(buf, sizeof(buf), "%s/%s", path, name);
|
|
Line 158: size += snprintf(t, end - t, "_head");
|
|
Line 160: size += snprintf(t, end - t, "_snapdir");
|
|
Line 162: size += snprintf(t, end - t, "_%llx", (long long unsigned)oid.hobj.snap);
|
|
Line 363: snprintf(path, sizeof(path), "%s/%s", dir, file);
|
|
GitHub\ceph\src\os\GenericFileStoreBackend.cc (1 hit)
|
|
Line 68: snprintf(fn, sizeof(fn), "%s/fiemap_test", get_basedir_path().c_str());
|
|
GitHub\ceph\src\os\GenericObjectMap.cc (7 hits)
|
|
Line 117: snprintf(t, end - t, "%.*X", (int)(sizeof(oid.hobj.get_hash())*2),
|
|
Line 126: t += snprintf(t, end - t, "%lld", (long long)oid.hobj.pool);
|
|
Line 138: t += snprintf(t, end - t, "head");
|
|
Line 140: t += snprintf(t, end - t, "snapdir");
|
|
Line 143: t += snprintf(t, end - t, "%016llx", (long long unsigned)oid.hobj.snap);
|
|
Line 152: t += snprintf(t, end - t, "%016llx", (long long unsigned)oid.generation);
|
|
Line 159: t += snprintf(t, end - t, "%x", (int)oid.shard_id);
|
|
GitHub\ceph\src\os\GenericObjectMap.h (1 hit)
|
|
Line 285: snprintf(buf, sizeof(buf), "%.*" PRId64, (int)(2*sizeof(seq)), seq);
|
|
GitHub\ceph\src\os\HashIndex.cc (2 hits)
|
|
Line 732: snprintf(buf, sizeof(buf), "%.*X", MAX_HASH_LEVEL, (uint32_t)oid.hobj.get_filestore_key());
|
|
Line 743: snprintf(buf, sizeof(buf), "%.*X", MAX_HASH_LEVEL, hash);
|
|
GitHub\ceph\src\os\IndexManager.cc (1 hit)
|
|
Line 129: snprintf(path, sizeof(path), "%s/current/%s", baseDir.c_str(), c.to_str().c_str());
|
|
GitHub\ceph\src\os\KeyValueStore.cc (3 hits)
|
|
Line 606: snprintf(fsid_fn, sizeof(fsid_fn), "%s/fsid", basedir.c_str());
|
|
Line 746: snprintf(fn, sizeof(fn), "%s/fsid", basedir.c_str());
|
|
Line 840: snprintf(buf, sizeof(buf), "%s/fsid", basedir.c_str());
|
|
GitHub\ceph\src\os\KeyValueStore.h (1 hit)
|
|
Line 220: snprintf(n, 100, "%lld", (long long)no);
|
|
GitHub\ceph\src\os\LFNIndex.cc (17 hits)
|
|
Line 385: snprintf(path, sizeof(path), "%s/%s", dir, file);
|
|
Line 602: t += snprintf(t, end - t, "_head");
|
|
Line 604: t += snprintf(t, end - t, "_snapdir");
|
|
Line 606: t += snprintf(t, end - t, "_%llx", (long long unsigned)oid.hobj.snap);
|
|
Line 607: snprintf(t, end - t, "_%.*X", (int)(sizeof(oid.hobj.get_hash())*2), oid.hobj.get_hash());
|
|
Line 656: t += snprintf(t, end - t, "head");
|
|
Line 658: t += snprintf(t, end - t, "snapdir");
|
|
Line 660: t += snprintf(t, end - t, "%llx", (long long unsigned)oid.hobj.snap);
|
|
Line 661: snprintf(t, end - t, "_%.*X", (int)(sizeof(oid.hobj.get_hash())*2), oid.hobj.get_hash());
|
|
Line 671: t += snprintf(t, end - t, "none");
|
|
Line 673: t += snprintf(t, end - t, "%llx", (long long unsigned)oid.hobj.pool);
|
|
Line 682: t += snprintf(t, end - t, "%llx", (long long unsigned)oid.generation);
|
|
Line 689: t += snprintf(t, end - t, "%x", (int)oid.shard_id);
|
|
Line 720: t += snprintf(t, end - t, "head");
|
|
Line 722: t += snprintf(t, end - t, "snapdir");
|
|
Line 724: t += snprintf(t, end - t, "%llx", (long long unsigned)oid.hobj.snap);
|
|
Line 725: snprintf(t, end - t, "_%.*X", (int)(sizeof(oid.hobj.get_hash())*2), oid.hobj.get_hash());
|
|
GitHub\ceph\src\os\LFNIndex.h (1 hit)
|
|
Line 146: snprintf(buf, sizeof(buf), "%d", index_version);
|
|
GitHub\ceph\src\os\ZFSFileStoreBackend.cc (4 hits)
|
|
Line 67: snprintf(path, sizeof(path), "%s/current", zfs.get_name(base_zh));
|
|
Line 137: snprintf(path, sizeof(path), "%s/current", zfs.get_name(base_zh));
|
|
Line 191: snprintf(path, sizeof(path), "%s@%s", zfs.get_name(current_zh), name.c_str());
|
|
Line 220: snprintf(path, sizeof(path), "%s@%s", zfs.get_name(current_zh), name.c_str());
|
|
GitHub\ceph\src\osd\ClassHandler.cc (1 hit)
|
|
Line 106: snprintf(fname, sizeof(fname), "%s/" CLS_PREFIX "%s" CLS_SUFFIX,
|
|
GitHub\ceph\src\osd\OSD.cc (3 hits)
|
|
Line 1396: snprintf(val, sizeof(val), "%s", CEPH_OSD_ONDISK_MAGIC);
|
|
Line 1401: snprintf(val, sizeof(val), "%d", whoami);
|
|
Line 5093: snprintf(nm, sizeof(nm), "disk_bw_test_%lld", (long long)pos);
|
|
GitHub\ceph\src\osd\OSD.h (5 hits)
|
|
Line 1089: snprintf(foo, sizeof(foo), "osdmap.%d", epoch);
|
|
Line 1094: snprintf(foo, sizeof(foo), "inc_osdmap.%d", epoch);
|
|
Line 1583: snprintf(lock_name, sizeof(lock_name), "%s.%d", "OSD:ShardedOpWQ:", i);
|
|
Line 1585: snprintf(
|
|
Line 1621: snprintf(lock_name, sizeof(lock_name), "%s%d", "OSD:ShardedOpWQ:", i);
|
|
GitHub\ceph\src\osd\osd_types.cc (3 hits)
|
|
Line 382: return snprintf(o, maxlen, "%llu.%xp%d", (unsigned long long)pool(), ps(), preferred());
|
|
Line 384: return snprintf(o, maxlen, "%llu.%x", (unsigned long long)pool(), ps());
|
|
Line 827: snprintf(
|
|
GitHub\ceph\src\osd\PGLog.h (1 hit)
|
|
Line 44: snprintf(buf, sizeof(buf), "read_log_error: %s", what);
|
|
GitHub\ceph\src\osd\SnapMapper.cc (1 hit)
|
|
Line 77: int len = snprintf(
|
|
GitHub\ceph\src\osd\SnapMapper.h (1 hit)
|
|
Line 157: int r = snprintf(buf, sizeof(buf), ".%x", (int)shard);
|
|
GitHub\ceph\src\osdc\Striper.cc (1 hit)
|
|
Line 82: snprintf(buf, sizeof(buf), object_format, (long long unsigned)objectno);
|
|
GitHub\ceph\src\osdc\Striper.h (1 hit)
|
|
Line 49: snprintf(buf, sizeof(buf), "%llx.%%08llx", (long long unsigned)ino);
|
|
GitHub\ceph\src\perfglue\heap_profiler.cc (3 hits)
|
|
Line 74: snprintf(path, sizeof(path), "%s", g_conf->log_file.c_str());
|
|
Line 78: snprintf(profile_name, profile_name_len, "./%s.profile",
|
|
Line 83: snprintf(profile_name, profile_name_len, "%s/%s.profile",
|
|
GitHub\ceph\src\rgw\rgw_bucket.cc (2 hits)
|
|
Line 1176: snprintf(buf, sizeof(buf), ":%d", shard_id);
|
|
Line 1307: snprintf(buf, sizeof(buf), ":%d", shard_id);
|
|
GitHub\ceph\src\rgw\rgw_bucket.h (1 hit)
|
|
Line 362: snprintf(buf, sizeof(buf), "%s.%d", prefix.c_str(), i);
|
|
GitHub\ceph\src\rgw\rgw_civetweb.cc (3 hits)
|
|
Line 122: snprintf(port_buf, sizeof(port_buf), "%d", port);
|
|
Line 133: snprintf(buf, sizeof(buf), "HTTP/1.1 %s %s\r\n", status, status_name);
|
|
Line 188: snprintf(buf, sizeof(buf), "%" PRIu64, len);
|
|
GitHub\ceph\src\rgw\rgw_client_io.cc (1 hit)
|
|
Line 36: int ret = vsnprintf(buf, size, format, ap);
|
|
GitHub\ceph\src\rgw\rgw_common.cc (3 hits)
|
|
Line 195: snprintf(buf + strlen(buf), sizeof(buf)-strlen(buf) ,":%03ld", timetest.tv_usec/1000);
|
|
Line 238: snprintf(name_low, meta_prefixes[0].len - 5 + name_len + 1, "%s%s", meta_prefixes[0].str + 5 /* skip HTTP_ */, name); // normalize meta prefix
|
|
Line 825: snprintf(buf, sizeof(buf), "%%%.2X", (int)(unsigned char)c);
|
|
GitHub\ceph\src\rgw\rgw_common.h (2 hits)
|
|
Line 645: snprintf(buf, sizeof(buf), "%llu", (long long)id);
|
|
Line 1299: snprintf(buf, sizeof(buf), "_%s_", ns.c_str());
|
|
GitHub\ceph\src\rgw\rgw_dencoder.cc (3 hits)
|
|
Line 165: snprintf(buf, sizeof(buf), "%d", (int)cur_stripe);
|
|
Line 172: snprintf(buf, sizeof(buf), ".%d", (int)cur_part_id);
|
|
Line 176: snprintf(buf, sizeof(buf), ".%d_%d", (int)cur_part_id, (int)cur_stripe);
|
|
GitHub\ceph\src\rgw\rgw_fcgi.cc (1 hit)
|
|
Line 51: snprintf(buf, sizeof(buf), "%" PRIu64, len);
|
|
GitHub\ceph\src\rgw\rgw_formats.cc (3 hits)
|
|
Line 141: vsnprintf(buf, LARGE_SIZE, fmt, ap);
|
|
Line 176: n = vsnprintf(p, size, fmt, ap);
|
|
Line 244: vsnprintf(buf, LARGE_SIZE, fmt, ap);
|
|
GitHub\ceph\src\rgw\rgw_gc.cc (1 hit)
|
|
Line 37: snprintf(buf, 32, ".%d", i);
|
|
GitHub\ceph\src\rgw\rgw_json_enc.cc (2 hits)
|
|
Line 292: snprintf(buf, len, "<none>");
|
|
Line 300: pos += snprintf(buf + pos, len - pos, "%s%s", sep, desc->str);
|
|
GitHub\ceph\src\rgw\rgw_loadgen.cc (2 hits)
|
|
Line 75: snprintf(buf, sizeof(buf), "%lld", (long long)req->content_length);
|
|
Line 91: snprintf(port_buf, sizeof(port_buf), "%d", req->port);
|
|
GitHub\ceph\src\rgw\rgw_log.cc (1 hit)
|
|
Line 328: snprintf(buf, sizeof(buf), "%d", s->err.http_ret);
|
|
GitHub\ceph\src\rgw\rgw_log.h (1 hit)
|
|
Line 86: snprintf(buf, sizeof(buf), "%llu", (long long)id);
|
|
GitHub\ceph\src\rgw\rgw_main.cc (2 hits)
|
|
Line 114: vsnprintf(buf, sizeof(buf), fmt, ap);
|
|
Line 968: snprintf(thread_pool_buf, sizeof(thread_pool_buf), "%d", (int)g_conf->rgw_thread_pool_size);
|
|
GitHub\ceph\src\rgw\rgw_metadata.h (1 hit)
|
|
Line 130: snprintf(buf, sizeof(buf), "%d", id);
|
|
GitHub\ceph\src\rgw\rgw_op.cc (3 hits)
|
|
Line 1631: snprintf(buf, sizeof(buf), "%08d", part_num_int);
|
|
Line 2999: snprintf(buf, sizeof(buf), "%08d", marker);
|
|
Line 3224: snprintf(&final_etag_str[CEPH_CRYPTO_MD5_DIGESTSIZE * 2], sizeof(final_etag_str) - CEPH_CRYPTO_MD5_DIGESTSIZE * 2,
|
|
GitHub\ceph\src\rgw\rgw_op.h (1 hit)
|
|
Line 954: snprintf(buf, 16, ".%d", num);
|
|
GitHub\ceph\src\rgw\rgw_rados.cc (16 hits)
|
|
Line 1783: snprintf(buf, sizeof(buf), ".%d", i);
|
|
Line 1811: snprintf(buf, sizeof(buf), ".%d", i);
|
|
Line 2058: snprintf(buf, sizeof(buf), RGW_USAGE_OBJ_PREFIX "%u", (unsigned)(val % max_shards));
|
|
Line 2176: snprintf(buf, sizeof(buf), "%u", (unsigned)(val % max_shards));
|
|
Line 2185: snprintf(buf, sizeof(buf), "%u", (unsigned)(val % max_shards));
|
|
Line 2645: snprintf(buf, sizeof(buf), "%s.%llu.%llu", zone.name.c_str(), (long long)iid, (long long)bid);
|
|
Line 6160: snprintf(buf, sizeof(buf), "%016llx", (unsigned long long)pending_info.time.sec());
|
|
Line 6860: snprintf(buf, sizeof(buf), "%lu", (unsigned long)iter->second.ver);
|
|
Line 6862: snprintf(buf, sizeof(buf), "%lu", (unsigned long)iter->second.master_ver);
|
|
Line 7536: snprintf(buf, sizeof(buf), "%d", shard_id);
|
|
Line 8365: snprintf(buf, sizeof(buf), "%s.%d", bucket_oid_base.c_str(), i);
|
|
Line 8372: snprintf(buf, sizeof(buf), "%s.%d", bucket_oid_base.c_str(), shard_id);
|
|
Line 8388: snprintf(buf, sizeof(buf), ":%d", i);
|
|
Line 8395: snprintf(buf, sizeof(buf), ":%d", shard_id);
|
|
Line 8418: snprintf(buf, sizeof(buf), "%s.%d", bucket_oid_base.c_str(), sid);
|
|
Line 8434: snprintf(buf, sizeof(buf), "%d", shard);
|
|
GitHub\ceph\src\rgw\rgw_rados.h (1 hit)
|
|
Line 2069: snprintf(buf, sizeof(buf), ".%llu.%llu", (unsigned long long)instance_id(), (unsigned long long)unique_num);
|
|
GitHub\ceph\src\rgw\rgw_replica_log.cc (1 hit)
|
|
Line 186: snprintf(buf, sizeof(buf), ".%d", shard_id);
|
|
GitHub\ceph\src\rgw\rgw_replica_log.h (1 hit)
|
|
Line 70: snprintf(buf, sizeof(buf), "%d", id);
|
|
GitHub\ceph\src\rgw\rgw_rest.cc (4 hits)
|
|
Line 311: snprintf(buf, sizeof(buf), "%d", s->err.http_ret);
|
|
Line 318: snprintf(buf, sizeof(buf), "%d", err);
|
|
Line 425: snprintf(buf, sizeof(buf), "%lld", (long long)t);
|
|
Line 606: snprintf(range_buf, sizeof(range_buf), "%lld-%lld/%lld", (long long)ofs, (long long)end, (long long)total);
|
|
GitHub\ceph\src\rgw\rgw_rest_conn.cc (1 hit)
|
|
Line 45: snprintf(buf, sizeof(buf), "%lld", (long long)objv->ver);
|
|
GitHub\ceph\src\rgw\rgw_rest_s3.cc (2 hits)
|
|
Line 479: snprintf(buf, sizeof(buf), "%lld", (long long)bucket.count);
|
|
Line 481: snprintf(buf, sizeof(buf), "%lld", (long long)bucket.size);
|
|
GitHub\ceph\src\rgw\rgw_rest_swift.cc (9 hits)
|
|
Line 61: snprintf(buf, sizeof(buf), "%0.5f", (double)now);
|
|
Line 64: snprintf(buf, sizeof(buf), "%lld", (long long)buckets_count);
|
|
Line 66: snprintf(buf, sizeof(buf), "%lld", (long long)buckets_object_count);
|
|
Line 68: snprintf(buf, sizeof(buf), "%lld", (long long)buckets_size);
|
|
Line 70: snprintf(buf, sizeof(buf), "%lld", (long long)buckets_size_rounded);
|
|
Line 292: snprintf(buf, sizeof(buf), "%lld.00000", (long long)s->bucket_info.creation_time);
|
|
Line 294: snprintf(buf, sizeof(buf), "%lld", (long long)bucket.count);
|
|
Line 296: snprintf(buf, sizeof(buf), "%lld", (long long)bucket.size);
|
|
Line 298: snprintf(buf, sizeof(buf), "%lld", (long long)bucket.size_rounded);
|
|
GitHub\ceph\src\rgw\rgw_user.cc (2 hits)
|
|
Line 513: snprintf(buf, len, "<none>");
|
|
Line 521: pos += snprintf(buf + pos, len - pos, "%s%s", sep, desc->str);
|
|
GitHub\ceph\src\rocksdb\db\column_family_test.cc (1 hit)
|
|
Line 233: snprintf(buf, sizeof(buf), "%s%d", (level ? "," : ""), f);
|
|
GitHub\ceph\src\rocksdb\db\compaction.cc (7 hits)
|
|
Line 258: snprintf(scratch->buffer + len, sizeof(scratch->buffer) - len, " + ");
|
|
Line 262: len += snprintf(scratch->buffer + len, sizeof(scratch->buffer) - len,
|
|
Line 265: snprintf(scratch->buffer + len, sizeof(scratch->buffer) - len,
|
|
Line 290: ret = snprintf(output + write, sz, "%" PRIu64 "(%s) ",
|
|
Line 302: snprintf(output, len, "Base version %" PRIu64
|
|
Line 312: write += snprintf(output + write, len - write, "], [");
|
|
Line 324: snprintf(output + write, len - write, "]");
|
|
GitHub\ceph\src\rocksdb\db\corruption_test.cc (1 hit)
|
|
Line 217: snprintf(buf, sizeof(buf), "%016d", i);
|
|
GitHub\ceph\src\rocksdb\db\cuckoo_table_db_test.cc (2 hits)
|
|
Line 98: snprintf(buf, sizeof(buf), "%s%d", (level ? "," : ""), f);
|
|
Line 192: snprintf(buf, sizeof(buf), "key_______%06d", i);
|
|
GitHub\ceph\src\rocksdb\db\c_test.c (4 hits)
|
|
Line 346: snprintf(dbname, sizeof(dbname),
|
|
Line 351: snprintf(dbbackupname, sizeof(dbbackupname),
|
|
Line 521: snprintf(keybuf, sizeof(keybuf), "k%020d", i);
|
|
Line 522: snprintf(valbuf, sizeof(valbuf), "v%020d", i);
|
|
GitHub\ceph\src\rocksdb\db\dbformat.cc (1 hit)
|
|
Line 31: snprintf(buf, sizeof(buf), "' @ %llu : %d",
|
|
GitHub\ceph\src\rocksdb\db\db_bench.cc (14 hits)
|
|
Line 422: snprintf(name, sizeof(name), "column_family_name_%06zu", i);
|
|
Line 1045: snprintf(rate, sizeof(rate), "%6.1f MB/s",
|
|
Line 1884: snprintf(buf, sizeof(buf), "(output: %.1f%%)",
|
|
Line 2354: snprintf(msg, sizeof(msg), "(%" PRIu64 " ops)", num_);
|
|
Line 2491: snprintf(msg, sizeof(msg), "(%" PRIu64 " of %" PRIu64 " found, "
|
|
Line 2557: snprintf(msg, sizeof(msg), "(%" PRIu64 " of %" PRIu64 " found)\n",
|
|
Line 2604: snprintf(msg, sizeof(msg), "(%" PRIu64 " of %" PRIu64 " found)",
|
|
Line 2704: snprintf(msg, sizeof(msg), "(%" PRIu64 " of %" PRIu64 " found)\n",
|
|
Line 2974: snprintf(msg, sizeof(msg),
|
|
Line 3032: snprintf(msg, sizeof(msg), "( reads:%" PRIu64 " writes:%" PRIu64 \
|
|
Line 3071: snprintf(msg, sizeof(msg),
|
|
Line 3123: snprintf(msg, sizeof(msg), "( updates:%" PRIu64 " found:%" PRIu64 ")",
|
|
Line 3160: snprintf(msg, sizeof(msg), "( updates:%" PRIu64 ")", readwrites_);
|
|
Line 3220: snprintf(msg, sizeof(msg),
|
|
GitHub\ceph\src\rocksdb\db\db_test.cc (43 hits)
|
|
Line 136: snprintf(buf, sizeof(buf), "key%06d", i);
|
|
Line 1003: snprintf(buf, sizeof(buf), "%s%d", (level ? "," : ""), f);
|
|
Line 5240: snprintf(key, sizeof(key), "B%010d", i);
|
|
Line 5291: snprintf(key, sizeof(key), "B%010d", i);
|
|
Line 5319: snprintf(key, sizeof(key), "B%010d", i);
|
|
Line 5426: snprintf(key, sizeof(key), "B%010d", i);
|
|
Line 5438: snprintf(key, sizeof(key), "B%010d", i);
|
|
Line 5452: snprintf(key, sizeof(key), "B%010d", i);
|
|
Line 5543: snprintf(key, sizeof(key), "B%08d%02d", i, j);
|
|
Line 5724: snprintf(key, sizeof(key), "B%08d%010d", i , i);
|
|
Line 5770: snprintf(key, sizeof(key), "B%08d%010d", i, i);
|
|
Line 5817: snprintf(key, sizeof(key), "B%08d%010d", i, i);
|
|
Line 5830: snprintf(key, sizeof(key), "B%08d%010d", i, i);
|
|
Line 5857: snprintf(first_key, sizeof(first_key), "%s0000%010d", "NULL", 1);
|
|
Line 5861: snprintf(key, sizeof(key), "%08d%010d", i, i);
|
|
Line 5866: snprintf(last_key, sizeof(last_key), "%s0000%010d", "NULL", 2);
|
|
Line 5881: snprintf(key, sizeof(key), "%08d%010d", i, i);
|
|
Line 5906: snprintf(key, sizeof(key), "B%010d", i);
|
|
Line 6472: snprintf(buf, sizeof(buf), "[%d]", i*10);
|
|
Line 7950: snprintf(keybuf, sizeof(keybuf), "%016d", key);
|
|
Line 7963: snprintf(valbuf, sizeof(valbuf), "%d.%d.%d.%d.%-1000d", key, id,
|
|
Line 7971: snprintf(valbuf, sizeof(valbuf), "%d.%d.%d.%d.%-1000d", key, id,
|
|
Line 8660: snprintf(buf, sizeof(buf), "%02d______:start", 0);
|
|
Line 8663: snprintf(buf, sizeof(buf), "%02d______:end", 10);
|
|
Line 8671: snprintf(buf, sizeof(buf), "%02d______:start", i);
|
|
Line 8674: snprintf(buf, sizeof(buf), "%02d______:end", i+1);
|
|
Line 8682: snprintf(buf, sizeof(buf), "%02d______:start", 0);
|
|
Line 8685: snprintf(buf, sizeof(buf), "%02d______:end",
|
|
Line 8703: snprintf(buf, sizeof(buf), "03______:");
|
|
Line 8772: snprintf(buf, sizeof(buf), "%016d", i);
|
|
Line 8795: snprintf(buf1, sizeof(buf1), "00a0%016d", i * 5);
|
|
Line 8804: snprintf(buf2, sizeof(buf2), "00a0%016d", i * 5 - 2);
|
|
Line 8813: snprintf(buf1, sizeof(buf1), "00a0%016d", i * 5);
|
|
Line 8822: snprintf(buf2, sizeof(buf2), "00a0%016d", i * 5 - 2);
|
|
Line 8850: snprintf(buf, sizeof(buf), "1%015d", i);
|
|
Line 8939: snprintf(buf, sizeof(buf), "%05d", 2*i);
|
|
Line 8992: snprintf(buf, sizeof(buf), "%016d", i);
|
|
Line 9016: snprintf(buf1, sizeof(buf1), "00a0%016d", i * 5);
|
|
Line 9025: snprintf(buf2, sizeof(buf2), "00a0%016d", i * 5 - 2);
|
|
Line 9034: snprintf(buf1, sizeof(buf1), "00a0%016d", i * 5);
|
|
Line 9043: snprintf(buf2, sizeof(buf2), "00a0%016d", i * 5 - 2);
|
|
Line 9072: snprintf(buf, sizeof(buf), "1%015d", i);
|
|
Line 9165: snprintf(buf, sizeof(buf), "%05d", 2 * i);
|
|
GitHub\ceph\src\rocksdb\db\fault_injection_test.cc (1 hit)
|
|
Line 595: snprintf(buf, sizeof(buf), "%016d", i);
|
|
GitHub\ceph\src\rocksdb\db\filename.cc (9 hits)
|
|
Line 51: // "\0" is automatically added by snprintf
|
|
Line 52: snprintf(dest + write_idx, len - write_idx, suffix);
|
|
Line 60: snprintf(buf, sizeof(buf), "/%06llu.%s",
|
|
Line 111: snprintf(out_buf, out_buf_size, "%" PRIu64, number);
|
|
Line 113: snprintf(out_buf, out_buf_size, "%" PRIu64
|
|
Line 123: snprintf(buf, sizeof(buf), "/MANIFEST-%06llu",
|
|
Line 145: snprintf(buf, sizeof(buf), kInfoLogPrefix);
|
|
Line 166: snprintf(buf, sizeof(buf), "%llu", static_cast<unsigned long long>(ts));
|
|
Line 177: snprintf(buf, sizeof(buf), "/METADB-%llu",
|
|
GitHub\ceph\src\rocksdb\db\internal_stats.cc (12 hits)
|
|
Line 30: snprintf(
|
|
Line 54: snprintf(buf, len,
|
|
Line 184: snprintf(buf, sizeof(buf), "%d",
|
|
Line 192: snprintf(buf, sizeof(buf),
|
|
Line 198: snprintf(buf, sizeof(buf), "%3d %8d %8.0f\n", level,
|
|
Line 314: snprintf(buf, sizeof(buf),
|
|
Line 340: snprintf(buf, sizeof(buf),
|
|
Line 349: snprintf(buf, sizeof(buf),
|
|
Line 365: snprintf(buf, sizeof(buf),
|
|
Line 382: snprintf(buf, sizeof(buf),
|
|
Line 487: snprintf(buf, sizeof(buf),
|
|
Line 492: snprintf(buf, sizeof(buf),
|
|
GitHub\ceph\src\rocksdb\db\log_and_apply_bench.cc (1 hit)
|
|
Line 25: snprintf(buf, sizeof(buf), "%016" PRIu64, num);
|
|
GitHub\ceph\src\rocksdb\db\log_reader.cc (1 hit)
|
|
Line 150: snprintf(buf, sizeof(buf), "unknown record type %u", record_type);
|
|
GitHub\ceph\src\rocksdb\db\log_test.cc (1 hit)
|
|
Line 35: snprintf(buf, sizeof(buf), "%d.", n);
|
|
GitHub\ceph\src\rocksdb\db\plain_table_db_test.cc (2 hits)
|
|
Line 165: snprintf(buf, sizeof(buf), "%s%d", (level ? "," : ""), f);
|
|
Line 1000: snprintf(buf, sizeof(buf), "key_______%06d", i);
|
|
GitHub\ceph\src\rocksdb\db\transaction_log_impl.cc (1 hit)
|
|
Line 210: snprintf(buf, sizeof(buf),
|
|
GitHub\ceph\src\rocksdb\db\version_set.cc (8 hits)
|
|
Line 1446: len = snprintf(scratch->buffer, sizeof(scratch->buffer),
|
|
Line 1451: snprintf(scratch->buffer + len, sizeof(scratch->buffer) - len, " files[");
|
|
Line 1454: int ret = snprintf(scratch->buffer + len, sz, "%d ", int(files_[i].size()));
|
|
Line 1462: snprintf(scratch->buffer + len, sizeof(scratch->buffer) - len, "]");
|
|
Line 1468: int len = snprintf(scratch->buffer, sizeof(scratch->buffer), "files_size[");
|
|
Line 1473: int ret = snprintf(scratch->buffer + len, sz,
|
|
Line 1485: snprintf(scratch->buffer + len, sizeof(scratch->buffer) - len, "]");
|
|
Line 2416: snprintf(msg, sizeof(msg),
|
|
GitHub\ceph\src\rocksdb\include\rocksdb\env.h (1 hit)
|
|
Line 654: snprintf(new_format, sizeof(new_format) - 1, "[%s] %s",
|
|
GitHub\ceph\src\rocksdb\include\rocksdb\slice.h (1 hit)
|
|
Line 81: snprintf(buf, 10, "%02X", (unsigned char)data_[i]);
|
|
GitHub\ceph\src\rocksdb\java\rocksjni\loggerjnicallback.cc (1 hit)
|
|
Line 87: p += vsnprintf(p, limit - p, format, backup_ap);
|
|
GitHub\ceph\src\rocksdb\linters\cpp_linter\cpplint.py (6 hits)
|
|
Line 3904: # When snprintf is used, the second argument shouldn't be a literal.
|
|
Line 3905: match = Search(r'snprintf\s*\(([^,]*),\s*([0-9]*)\s*,', line)
|
|
Line 3907: # If 2nd arg is zero, snprintf is used to calculate size.
|
|
Line 3910: 'to snprintf.' % (match.group(1), match.group(2)))
|
|
Line 3915: 'Never use sprintf. Use snprintf instead.')
|
|
Line 3919: 'Almost always, snprintf is better than %s' % match.group(1))
|
|
GitHub\ceph\src\rocksdb\port\stack_trace.cc (3 hits)
|
|
Line 39: snprintf(link, sizeof(link), "/proc/%d/exe", getpid());
|
|
Line 58: snprintf(cmd, kLineMax, "addr2line %p -e %s -f -C 2>&1", frame, executable);
|
|
Line 81: snprintf(cmd, kLineMax, "xcrun atos %p -p %d 2>&1", frame, pid);
|
|
GitHub\ceph\src\rocksdb\table\adaptive_table_factory.cc (4 hits)
|
|
Line 84: snprintf(buffer, kBufferSize, " write factory (%s) options:\n%s\n",
|
|
Line 90: snprintf(buffer, kBufferSize, " %s options:\n%s\n",
|
|
Line 96: snprintf(buffer, kBufferSize, " %s options:\n%s\n",
|
|
Line 102: snprintf(buffer, kBufferSize, " %s options:\n%s\n",
|
|
GitHub\ceph\src\rocksdb\table\block_based_table_factory.cc (16 hits)
|
|
Line 93: snprintf(buffer, kBufferSize, " flush_block_policy_factory: %s (%p)\n",
|
|
Line 97: snprintf(buffer, kBufferSize, " cache_index_and_filter_blocks: %d\n",
|
|
Line 100: snprintf(buffer, kBufferSize, " index_type: %d\n",
|
|
Line 103: snprintf(buffer, kBufferSize, " hash_index_allow_collision: %d\n",
|
|
Line 106: snprintf(buffer, kBufferSize, " checksum: %d\n",
|
|
Line 109: snprintf(buffer, kBufferSize, " no_block_cache: %d\n",
|
|
Line 112: snprintf(buffer, kBufferSize, " block_cache: %p\n",
|
|
Line 116: snprintf(buffer, kBufferSize, " block_cache_size: %zd\n",
|
|
Line 120: snprintf(buffer, kBufferSize, " block_cache_compressed: %p\n",
|
|
Line 124: snprintf(buffer, kBufferSize, " block_cache_compressed_size: %zd\n",
|
|
Line 128: snprintf(buffer, kBufferSize, " block_size: %zd\n",
|
|
Line 131: snprintf(buffer, kBufferSize, " block_size_deviation: %d\n",
|
|
Line 134: snprintf(buffer, kBufferSize, " block_restart_interval: %d\n",
|
|
Line 137: snprintf(buffer, kBufferSize, " filter_policy: %s\n",
|
|
Line 141: snprintf(buffer, kBufferSize, " whole_key_filtering: %d\n",
|
|
Line 143: snprintf(buffer, kBufferSize, " format_version: %d\n",
|
|
GitHub\ceph\src\rocksdb\table\block_test.cc (1 hit)
|
|
Line 37: snprintf(buf, sizeof(buf), "%6d%4d", primary_key, secondary_key);
|
|
GitHub\ceph\src\rocksdb\table\cuckoo_table_factory.cc (4 hits)
|
|
Line 49: snprintf(buffer, kBufferSize, " hash_table_ratio: %lf\n",
|
|
Line 52: snprintf(buffer, kBufferSize, " max_search_depth: %u\n",
|
|
Line 55: snprintf(buffer, kBufferSize, " cuckoo_block_size: %u\n",
|
|
Line 58: snprintf(buffer, kBufferSize, " identity_as_first_hash: %d\n",
|
|
GitHub\ceph\src\rocksdb\table\format.cc (1 hit)
|
|
Line 63: snprintf(buf, sizeof(buf), "%02X",
|
|
GitHub\ceph\src\rocksdb\table\plain_table_factory.cc (8 hits)
|
|
Line 51: snprintf(buffer, kBufferSize, " user_key_len: %u\n",
|
|
Line 54: snprintf(buffer, kBufferSize, " bloom_bits_per_key: %d\n",
|
|
Line 57: snprintf(buffer, kBufferSize, " hash_table_ratio: %lf\n",
|
|
Line 60: snprintf(buffer, kBufferSize, " index_sparseness: %zu\n",
|
|
Line 63: snprintf(buffer, kBufferSize, " huge_page_tlb_size: %zu\n",
|
|
Line 66: snprintf(buffer, kBufferSize, " encoding_type: %d\n",
|
|
Line 69: snprintf(buffer, kBufferSize, " full_scan_mode: %d\n",
|
|
Line 72: snprintf(buffer, kBufferSize, " store_index_in_file: %d\n",
|
|
GitHub\ceph\src\rocksdb\table\table_reader_bench.cc (1 hit)
|
|
Line 39: snprintf(buf, sizeof(buf), "%04d__key___%04d", i, j);
|
|
GitHub\ceph\src\rocksdb\table\table_test.cc (1 hit)
|
|
Line 1990: snprintf(name, sizeof(name), "rocksdb.num-files-at-level%d", level);
|
|
GitHub\ceph\src\rocksdb\third-party\fbson\FbsonStream.h (6 hits)
|
|
Line 110: // snprintf automatically adds a NULL, so we need one more char
|
|
Line 115: int len = snprintf(head_ + size_, MAX_INT_DIGITS + 1, "%d", i);
|
|
Line 122: // snprintf automatically adds a NULL, so we need one more char
|
|
Line 127: int len = snprintf(head_ + size_, MAX_INT64_DIGITS + 1, "%" PRIi64, l);
|
|
Line 134: // snprintf automatically adds a NULL, so we need one more char
|
|
Line 139: int len = snprintf(head_ + size_, MAX_DOUBLE_DIGITS + 1, "%.15g", d);
|
|
GitHub\ceph\src\rocksdb\third-party\gtest-1.7.0\fused-src\gtest\gtest-all.cc (6 hits)
|
|
Line 334: // Declares vsnprintf(). This header is not available on Windows.
|
|
Line 1603: # define vsnprintf _vsnprintf
|
|
Line 1603: # define vsnprintf _vsnprintf
|
|
Line 9040: snprintf(full_pattern, full_regex_len, "^(%s)$", regex);
|
|
Line 9301: // We don't use snprintf or strncpy, as they trigger a warning when
|
|
Line 9736: GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]);
|
|
GitHub\ceph\src\rocksdb\third-party\gtest-1.7.0\fused-src\gtest\gtest.h (13 hits)
|
|
Line 3472: // MSVC "deprecates" snprintf and issues warnings wherever it is used. In
|
|
Line 3473: // order to avoid these warnings, we need to use _snprintf or _snprintf_s on
|
|
Line 3473: // order to avoid these warnings, we need to use _snprintf or _snprintf_s on
|
|
Line 3474: // MSVC-based platforms. We map the GTEST_SNPRINTF_ macro to the appropriate
|
|
Line 3476: // snprintf is a variadic function.
|
|
Line 3479: # define GTEST_SNPRINTF_(buffer, size, format, ...) \
|
|
Line 3480: _snprintf_s(buffer, size, size, format, __VA_ARGS__)
|
|
Line 3482: // Windows CE does not define _snprintf_s and MSVC prior to 2005 doesn't
|
|
Line 3483: // complain about _snprintf.
|
|
Line 3484: # define GTEST_SNPRINTF_ _snprintf
|
|
Line 3484: # define GTEST_SNPRINTF_ _snprintf
|
|
Line 3486: # define GTEST_SNPRINTF_ snprintf
|
|
Line 3486: # define GTEST_SNPRINTF_ snprintf
|
|
GitHub\ceph\src\rocksdb\tools\db_stress.cc (1 hit)
|
|
Line 417: snprintf(buf, 10, "%02X", (unsigned char)str[i]);
|
|
GitHub\ceph\src\rocksdb\util\auto_roll_logger.cc (1 hit)
|
|
Line 46: int count = vsnprintf(buffer, MAXBUFFERSIZE, format, args);
|
|
GitHub\ceph\src\rocksdb\util\benchharness.cc (1 hit)
|
|
Line 298: snprintf(a, sizeof(a), "%.*f%s", decimals, scaledValue, scale->suffix);
|
|
GitHub\ceph\src\rocksdb\util\db_info_dumper.cc (2 hits)
|
|
Line 66: snprintf(str, sizeof(str), "%" PRIu64, file_size);
|
|
Line 119: snprintf(str, sizeof(str), "%" PRIu64, file_size);
|
|
GitHub\ceph\src\rocksdb\util\env_hdfs.cc (2 hits)
|
|
Line 321: p += snprintf(p, limit - p,
|
|
Line 336: p += vsnprintf(p, limit - p, format, backup_ap);
|
|
GitHub\ceph\src\rocksdb\util\env_posix.cc (4 hits)
|
|
Line 1368: snprintf(buf, sizeof(buf), "/tmp/rocksdbtest-%d", int(geteuid()));
|
|
Line 1498: snprintf(p, maxsize,
|
|
Line 1767: snprintf(name_buf, sizeof name_buf, "rocksdb:bg%zu", bgthreads_.size());
|
|
Line 1936: snprintf(uuid2,
|
|
GitHub\ceph\src\rocksdb\util\env_test.cc (3 hits)
|
|
Line 502: snprintf(base, sizeof(base), "/tmp/rocksdbtest-%d",
|
|
Line 782: int n = vsnprintf(new_format, sizeof(new_format) - 1, format, backup_ap);
|
|
Line 854: int n = vsnprintf(new_format, sizeof(new_format) - 1, format, backup_ap);
|
|
GitHub\ceph\src\rocksdb\util\event_logger_test.cc (1 hit)
|
|
Line 19: vsnprintf(buffer_, sizeof(buffer_), format, ap);
|
|
GitHub\ceph\src\rocksdb\util\histogram.cc (4 hits)
|
|
Line 151: snprintf(buf, sizeof(buf),
|
|
Line 155: snprintf(buf, sizeof(buf),
|
|
Line 159: snprintf(buf, sizeof(buf),
|
|
Line 171: snprintf(buf, sizeof(buf),
|
|
GitHub\ceph\src\rocksdb\util\ldb_cmd.cc (2 hits)
|
|
Line 1294: snprintf(buf, sizeof(buf), "%s%s", (i ? "," : ""), property.c_str());
|
|
Line 1314: snprintf(buf, sizeof(buf), "%s%s", (i ? "," : ""), property.c_str());
|
|
GitHub\ceph\src\rocksdb\util\ldb_cmd.h (1 hit)
|
|
Line 153: snprintf(buf, 10, "%02X", (unsigned char)str[i]);
|
|
GitHub\ceph\src\rocksdb\util\logging.cc (16 hits)
|
|
Line 34: return snprintf(output, len, "%" PRIu64 " us", micros);
|
|
Line 36: return snprintf(output, len, "%.3lf ms",
|
|
Line 39: return snprintf(output, len, "%.3lf sec",
|
|
Line 42: return snprintf(output, len, "%02" PRIu64 ":%05.3f M:S",
|
|
Line 46: return snprintf(output, len,
|
|
Line 61: return snprintf(output, len, "%" PRIu64 "TB", bytes >> 40);
|
|
Line 63: return snprintf(output, len, "%" PRIu64 "GB", bytes >> 30);
|
|
Line 65: return snprintf(output, len, "%" PRIu64 "MB", bytes >> 20);
|
|
Line 67: return snprintf(output, len, "%" PRIu64 "KB", bytes >> 10);
|
|
Line 69: return snprintf(output, len, "%" PRIu64 "B", bytes);
|
|
Line 75: snprintf(buf, sizeof(buf), "%" PRIu64, num);
|
|
Line 86: snprintf(buf, sizeof(buf), "\\x%02x",
|
|
Line 103: snprintf(buf, sizeof(buf), "%" PRIi64, num);
|
|
Line 105: snprintf(buf, sizeof(buf), "%" PRIi64 "K", num / 1000);
|
|
Line 107: snprintf(buf, sizeof(buf), "%" PRIi64 "M", num / 1000000);
|
|
Line 109: snprintf(buf, sizeof(buf), "%" PRIi64 "G", num / 1000000000);
|
|
GitHub\ceph\src\rocksdb\util\log_buffer.cc (1 hit)
|
|
Line 35: auto n = vsnprintf(p, limit - p, format, backup_ap);
|
|
GitHub\ceph\src\rocksdb\util\manual_compaction_test.cc (1 hit)
|
|
Line 25: snprintf(buf, sizeof(buf), "my_key_%d", i);
|
|
GitHub\ceph\src\rocksdb\util\mock_env.cc (2 hits)
|
|
Line 341: p += snprintf(p, limit - p,
|
|
Line 355: p += vsnprintf(p, limit - p, format, backup_ap);
|
|
GitHub\ceph\src\rocksdb\util\mutable_cf_options.cc (1 hit)
|
|
Line 108: snprintf(buf, sizeof(buf), "%d, ", m);
|
|
GitHub\ceph\src\rocksdb\util\posix_logger.h (2 hits)
|
|
Line 87: p += snprintf(p, limit - p,
|
|
Line 102: p += vsnprintf(p, limit - p, format, backup_ap);
|
|
GitHub\ceph\src\rocksdb\util\sst_dump_test.cc (14 hits)
|
|
Line 26: snprintf(buf, sizeof(buf), "k_%04d", i);
|
|
Line 33: snprintf(buf, sizeof(buf), "v_%04d", i);
|
|
Line 94: snprintf(usage[0], optLength, "./sst_dump");
|
|
Line 95: snprintf(usage[1], optLength, "--command=raw");
|
|
Line 96: snprintf(usage[2], optLength, "--file=rocksdb_sst_test.sst");
|
|
Line 116: snprintf(usage[0], optLength, "./sst_dump");
|
|
Line 117: snprintf(usage[1], optLength, "--command=raw");
|
|
Line 118: snprintf(usage[2], optLength, "--file=rocksdb_sst_test.sst");
|
|
Line 138: snprintf(usage[0], optLength, "./sst_dump");
|
|
Line 139: snprintf(usage[1], optLength, "--command=raw");
|
|
Line 140: snprintf(usage[2], optLength, "--file=rocksdb_sst_test.sst");
|
|
Line 160: snprintf(usage[0], optLength, "./sst_dump");
|
|
Line 161: snprintf(usage[1], optLength, "--show_properties");
|
|
Line 162: snprintf(usage[2], optLength, "--file=rocksdb_sst_test.sst");
|
|
GitHub\ceph\src\rocksdb\util\sst_dump_tool.cc (1 hit)
|
|
Line 159: snprintf(error_msg_buffer, sizeof(error_msg_buffer) - 1,
|
|
GitHub\ceph\src\rocksdb\util\statistics.cc (2 hits)
|
|
Line 105: snprintf(buffer, kBufferSize, "%s COUNT : %" PRIu64 "\n",
|
|
Line 115: snprintf(
|
|
GitHub\ceph\src\rocksdb\util\status.cc (1 hit)
|
|
Line 77: snprintf(tmp, sizeof(tmp), "Unknown code(%d): ",
|
|
GitHub\ceph\src\rocksdb\utilities\backupable\backupable_db.cc (5 hits)
|
|
Line 95: snprintf(result, sizeof(result), "# success backup: %u, # fail backup: %u",
|
|
Line 1311: len += snprintf(buf.get(), buf_size, "%" PRId64 "\n", timestamp_);
|
|
Line 1312: len += snprintf(buf.get() + len, buf_size - len, "%" PRIu64 "\n",
|
|
Line 1314: len += snprintf(buf.get() + len, buf_size - len, "%zu\n", files_.size());
|
|
Line 1317: len += snprintf(buf.get() + len, buf_size - len, "%s crc32 %u\n",
|
|
GitHub\ceph\src\rocksdb\utilities\spatialdb\spatial_db.cc (2 hits)
|
|
Line 238: snprintf(buf, sizeof(buf), "%" PRIu64, iter.second.get_int());
|
|
Line 244: snprintf(buf, sizeof(buf), "%lf", iter.second.get_double());
|
|
GitHub\ceph\src\test\bufferlist.cc (5 hits)
|
|
Line 157: snprintf(cmd, sizeof(cmd), "echo ABC > %s", FILENAME);
|
|
Line 186: snprintf(cmd, sizeof(cmd), "echo ABC > %s", FILENAME);
|
|
Line 1926: snprintf(cmd, sizeof(cmd), "echo ABC > %s ; chmod 0 %s", FILENAME, FILENAME);
|
|
Line 1930: snprintf(cmd, sizeof(cmd), "chmod +r %s", FILENAME);
|
|
Line 1942: snprintf(cmd, sizeof(cmd), "echo ABC > %s", FILENAME);
|
|
GitHub\ceph\src\test\cls_log\test_cls_log.cc (1 hit)
|
|
Line 60: snprintf(buf, sizeof(buf), "%d", i);
|
|
GitHub\ceph\src\test\cls_refcount\test_cls_refcount.cc (1 hit)
|
|
Line 253: snprintf(buf, sizeof(buf), "tag%d", i);
|
|
GitHub\ceph\src\test\cls_rgw\test_cls_rgw.cc (4 hits)
|
|
Line 36: snprintf(buf, sizeof(buf), "-%d", i);
|
|
Line 380: snprintf(buf, sizeof(buf), "-%d.%d", i, j);
|
|
Line 403: snprintf(buf, sizeof(buf), "chain-%d", i);
|
|
Line 445: snprintf(buf, sizeof(buf), "chain-%d", i);
|
|
GitHub\ceph\src\test\cls_statelog\test_cls_statelog.cc (2 hits)
|
|
Line 49: snprintf(buf, sizeof(buf), "%d", *id);
|
|
Line 57: snprintf(buf, sizeof(buf), "obj-%d", num);
|
|
GitHub\ceph\src\test\daemon_config.cc (1 hit)
|
|
Line 281: snprintf(tmpfile, sizeof(tmpfile), "%s/daemon_config_test.%d",
|
|
GitHub\ceph\src\test\libcephfs\multiclient.cc (2 hits)
|
|
Line 38: snprintf(name, sizeof(name), "foo.%d", getpid());
|
|
Line 78: snprintf(name, sizeof(name), "foo.%d", getpid());
|
|
GitHub\ceph\src\test\librados\misc.cc (1 hit)
|
|
Line 591: snprintf(n, sizeof(n), "a%d", i);
|
|
GitHub\ceph\src\test\librados_test_stub\LibradosTestStub.cc (1 hit)
|
|
Line 1009: int n = vsnprintf(buf, size, format, ap);
|
|
GitHub\ceph\src\test\librbd\fsx.cc (3 hits)
|
|
Line 206: vsnprintf(buffer, BUF_SIZE, fmt, args);
|
|
Line 1371: snprintf(buf, len, "%s/fsx-%s-parent%d",
|
|
Line 1378: snprintf(buf, len, "%s-clone%d", iname, clones);
|
|
GitHub\ceph\src\test\msgr\test_msgr.cc (2 hits)
|
|
Line 841: snprintf(addr, sizeof(addr), "127.0.0.1:%d", base_port+i);
|
|
Line 856: snprintf(addr, sizeof(addr), "127.0.0.1:%d", base_port+i+servers);
|
|
GitHub\ceph\src\test\ObjectMap\test_object_map.cc (1 hit)
|
|
Line 37: snprintf(buf, sizeof(buf), "%.10u", i);
|
|
GitHub\ceph\src\test\objectstore\DeterministicOpSequence.cc (1 hit)
|
|
Line 438: snprintf(buf, 100, "%d.%x_head", pool_id, pg_id);
|
|
GitHub\ceph\src\test\objectstore\FileStoreTracker.cc (1 hit)
|
|
Line 198: snprintf(buf, sizeof(buf), "%*llu", 20, (unsigned long long int)seq);
|
|
GitHub\ceph\src\test\objectstore\store_test.cc (4 hits)
|
|
Line 143: snprintf(buf, 100, "1.%x_head", pg_id);
|
|
Line 366: snprintf(buf, sizeof(buf), "%d", i);
|
|
Line 466: snprintf(buf, sizeof(buf), "%u", seq);
|
|
Line 1268: snprintf(buf, sizeof(buf), "%d", i);
|
|
GitHub\ceph\src\test\objectstore\TestObjectStoreState.cc (3 hits)
|
|
Line 93: snprintf(buf, 100, "0.%d_head", id);
|
|
Line 94: snprintf(meta_buf, 100, "pglog_0.%d_head", id);
|
|
Line 189: snprintf(buf, 100, "obj%d", id);
|
|
GitHub\ceph\src\test\os\TestLFNIndex.cc (2 hits)
|
|
Line 263: snprintf(buf, sizeof(buf), "%d", index_version);
|
|
Line 431: snprintf(buf, sizeof(buf), "%d", index_version);
|
|
GitHub\ceph\src\test\rgw\test_rgw_manifest.cc (1 hit)
|
|
Line 50: snprintf(buf, sizeof(buf), "%d", ++i);
|
|
GitHub\ceph\src\test\system\rados_list_parallel.cc (2 hits)
|
|
Line 81: snprintf(oid, sizeof(oid), "%d.obj", i);
|
|
Line 166: snprintf(oid, sizeof(oid), "%d%s", i, m_suffix.c_str());
|
|
GitHub\ceph\src\test\system\st_rados_create_pool.cc (1 hit)
|
|
Line 92: snprintf(oid, sizeof(oid), "%d%s", i, m_suffix.c_str());
|
|
GitHub\ceph\src\test\system\st_rados_delete_objs.cc (1 hit)
|
|
Line 59: snprintf(oid, sizeof(oid), "%d%s", i, m_suffix.c_str());
|
|
GitHub\ceph\src\test\system\systest_runnable.cc (4 hits)
|
|
Line 187: snprintf(extra, sizeof(extra), "_[%d]", do_gettid());
|
|
Line 189: snprintf(extra, sizeof(extra), "_[%d]", getpid());
|
|
Line 192: snprintf(m_id_str, SysTestRunnable::ID_STR_SZ, "thread_%d%s", m_id, extra);
|
|
Line 194: snprintf(m_id_str, SysTestRunnable::ID_STR_SZ, "process_%d%s", m_id, extra);
|
|
GitHub\ceph\src\test\test_filejournal.cc (1 hit)
|
|
Line 96: snprintf(path, sizeof(path), "/var/tmp/ceph_test_filejournal.tmp.%d", rand());
|
|
GitHub\ceph\src\test\test_trans.cc (1 hit)
|
|
Line 66: snprintf(f, sizeof(f), "foo%d\n", i);
|
|
GitHub\ceph\src\tools\cephfs\JournalScanner.cc (1 hit)
|
|
Line 334: snprintf(name, sizeof(name), "%llx.%08llx",
|
|
GitHub\ceph\src\tools\crushtool.cc (2 hits)
|
|
Line 674: snprintf(format, sizeof(format)-1, "%s%%d", l.name);
|
|
Line 678: snprintf(name, sizeof(name), format, i);
|
|
GitHub\ceph\src\tools\psim.cc (2 hits)
|
|
Line 53: snprintf(nspace, sizeof(nspace), "n%d", n);
|
|
Line 57: snprintf(foo, sizeof(foo), "%d.%d", f, b);
|
|
GitHub\ceph\src\tools\radosacl.cc (2 hits)
|
|
Line 143: snprintf(buf, 128, "%s", ctime(&tm));
|
|
Line 154: snprintf(id.id, ID_SIZE + 1, "%.16x", 0x1234);
|
|
GitHub\ceph\src\tools\scratchtool.c (1 hit)
|
|
Line 219: snprintf(buf, 128, "%s", ctime(&tm));
|
|
GitHub\ceph\src\tools\scratchtoolpp.cc (1 hit)
|
|
Line 102: snprintf(buf, 128, "%s", ctime(&tm));
|
|
Search "strlen" (752 hits in 153 files)
|
|
GitHub\ceph\src\civetweb\examples\chat\chat.c (1 hit)
|
|
Line 78: mg_get_var(qs, strlen(qs == NULL ? "" : qs), name, dst, dst_len);
|
|
GitHub\ceph\src\civetweb\examples\post\post.c (1 hit)
|
|
Line 40: (int) strlen(html_form), html_form);
|
|
GitHub\ceph\src\civetweb\examples\upload\upload.c (1 hit)
|
|
Line 38: (int) strlen(html_form), html_form);
|
|
GitHub\ceph\src\civetweb\examples\websocket\WebSockCallbacks.c (1 hit)
|
|
Line 176: mg_websocket_write(socketList[i]->conn, WEBSOCKET_OPCODE_TEXT, msg, strlen(msg));
|
|
GitHub\ceph\src\civetweb\examples\ws_server\ws_server.c (2 hits)
|
|
Line 64: mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, tstr, strlen(tstr));
|
|
Line 86: mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, tstr, strlen(tstr));
|
|
GitHub\ceph\src\civetweb\src\CivetServer.cpp (4 hits)
|
|
Line 144: urlDecode(src, strlen(src), dst, is_form_url_encoded);
|
|
Line 211: return getParam(formParams, strlen(formParams), name, dst, occurrence);
|
|
Line 228: name_len = strlen(name);
|
|
Line 257: urlEncode(src, strlen(src), dst, append);
|
|
GitHub\ceph\src\civetweb\src\civetweb.c (38 hits)
|
|
Line 982: return mg_strndup(str, strlen(str));
|
|
Line 987: int i, big_len = (int)strlen(big_str), small_len = (int)strlen(small_str);
|
|
Line 987: int i, big_len = (int)strlen(big_str), small_len = (int)strlen(small_str);
|
|
Line 1260: list = val->ptr + strlen(val->ptr);
|
|
Line 1302: len = (int) strlen(str + j);
|
|
Line 1613: path + i + 2, strlen(path + i + 1));
|
|
Line 1704: int last = path[strlen(path) - 1];
|
|
Line 1951: char *e = s + strlen(s) - 1;
|
|
Line 2527: name_len = strlen(name);
|
|
Line 2575: name_len = (int) strlen(var_name);
|
|
Line 2576: end = s + strlen(s);
|
|
Line 2727: for (p = buf + strlen(buf); p > buf + 1; p--) {
|
|
Line 2731: (int)strlen(conn->ctx->config[CGI_EXTENSIONS]), buf) > 0
|
|
Line 2735: (int)strlen(conn->ctx->config[LUA_SCRIPT_EXTENSIONS]), buf) > 0
|
|
Line 2744: memmove(p + 2, p + 1, strlen(p + 1) + 1); /* +1 is for
|
|
Line 2960: path_len = strlen(path);
|
|
Line 2982: path_len = strlen(path);
|
|
Line 2997: vec->len = strlen(vec->ptr);
|
|
Line 3025: md5_append(&ctx, (const md5_byte_t *) p, (int) strlen(p));
|
|
Line 3050: strlen(response) != 32
|
|
Line 3093: for (p = path, e = p + strlen(p) - 1; e > p; e--) {
|
|
Line 3248: l = strlen(workdata->buf);
|
|
Line 3612: return match_prefix(pw_pattern, (int)strlen(pw_pattern), path) > 0 ||
|
|
Line 3613: (pattern != NULL && match_prefix(pattern, (int)strlen(pattern), path) > 0);
|
|
Line 4082: size_t n = strlen(path);
|
|
Line 4673: of size MG_BUF_LEN to get the tag. So strlen(tag) is
|
|
Line 4693: len = strlen(path);
|
|
Line 4706: (int)strlen(conn->ctx->config[SSI_EXTENSIONS]), path) > 0) {
|
|
Line 5171: SHA1Update(&sha_ctx, (unsigned char *) buf, (uint32_t)strlen(buf));
|
|
Line 5386: (int)strlen(conn->ctx->config[LUA_WEBSOCKET_EXTENSIONS]),
|
|
Line 5517: boundary_len = (int)strlen(boundary);
|
|
Line 5653: size_t urilen = strlen(uri);
|
|
Line 5719: size_t urilen = strlen(uri);
|
|
Line 5764: uri_len = (int) strlen(ri->uri);
|
|
Line 5865: (int)strlen(conn->ctx->config[LUA_SERVER_PAGE_EXTENSIONS]),
|
|
Line 5870: (int)strlen(conn->ctx->config[LUA_SCRIPT_EXTENSIONS]),
|
|
Line 5877: (int)strlen(conn->ctx->config[CGI_EXTENSIONS]),
|
|
Line 5883: (int)strlen(conn->ctx->config[SSI_EXTENSIONS]),
|
|
GitHub\ceph\src\civetweb\src\main.c (8 hits)
|
|
Line 226: len = strlen(str) + 1;
|
|
Line 325: for (j = strlen(line)-1; isspace(* (unsigned char *) &line[j]) || iscntrl(* (unsigned char *) &line[j]); ) line[j--]=0;
|
|
Line 410: assert((strlen(mg_version())+12)<sizeof(server_base_name));
|
|
Line 509: strncat(path, "/", sizeof(path) - strlen(path) - 1);
|
|
Line 510: strncat(path, option_value, sizeof(path) - strlen(path) - 1);
|
|
Line 792: title = malloc(strlen(server_name)+16);
|
|
Line 834: if (strlen(inBuf->buffer)>0) {
|
|
Line 846: assert(strlen(inBuf->buffer) < inBuf->buflen);
|
|
GitHub\ceph\src\civetweb\src\mod_lua.inl (3 hits)
|
|
Line 235: *sz = strlen(ret);
|
|
Line 243: *sz = strlen(ret);
|
|
Line 849: txt_len = strlen(txt);
|
|
GitHub\ceph\src\civetweb\src\third_party\lfs.c (3 hits)
|
|
Line 266: ln = (char*)malloc(pathl + strlen(lockfile) + 1);
|
|
Line 305: ln = (char*)malloc(pathl + strlen(lockfile) + 1);
|
|
Line 543: if (strlen(path) > MAX_PATH-2)
|
|
GitHub\ceph\src\civetweb\src\third_party\lsqlite3.c (9 hits)
|
|
Line 41: #define lua_strlen lua_rawlen
|
|
Line 478: return sqlite3_bind_text(vm, index, lua_tostring(L, lindex), lua_strlen(L, lindex), SQLITE_TRANSIENT);
|
|
Line 524: int len = lua_strlen(L, 3);
|
|
Line 799: sqlite3_result_text(ctx->ctx, luaL_checkstring(L, 2), lua_strlen(L, 2), SQLITE_TRANSIENT);
|
|
Line 816: int size = lua_strlen(L, 2);
|
|
Line 831: int size = lua_strlen(L, 2);
|
|
Line 852: int size = lua_strlen(L, 2);
|
|
Line 1003: int size = lua_strlen(L, -1);
|
|
Line 1660: int sql_len = lua_strlen(L, 2);
|
|
GitHub\ceph\src\civetweb\src\third_party\lua-5.2.3\doc\manual.html (1 hit)
|
|
Line 567: return strlen(op) -- primitive string length
|
|
GitHub\ceph\src\civetweb\src\third_party\lua-5.2.3\src\lauxlib.c (5 hits)
|
|
Line 368: *len = (def ? strlen(def) : 0);
|
|
Line 467: luaL_addlstring(B, s, strlen(s));
|
|
Line 692: return luaL_loadbuffer(L, s, strlen(s), s);
|
|
Line 773: if (e == NULL) e = fname + strlen(fname);
|
|
Line 905: size_t l = strlen(p);
|
|
GitHub\ceph\src\civetweb\src\third_party\lua-5.2.3\src\ldblib.c (1 hit)
|
|
Line 351: if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
|
|
GitHub\ceph\src\civetweb\src\third_party\lua-5.2.3\src\liolib.c (2 hits)
|
|
Line 268: luaL_error(L, "standard %s file is closed", findex + strlen(IO_PREFIX));
|
|
Line 381: l = strlen(p);
|
|
GitHub\ceph\src\civetweb\src\third_party\lua-5.2.3\src\loadlib.c (1 hit)
|
|
Line 343: if (l == NULL) l = path + strlen(path);
|
|
GitHub\ceph\src\civetweb\src\third_party\lua-5.2.3\src\lobject.c (3 hits)
|
|
Line 190: pushstr(L, s, strlen(s));
|
|
Line 227: pushstr(L, fmt, strlen(fmt));
|
|
Line 253: size_t l = strlen(source);
|
|
GitHub\ceph\src\civetweb\src\third_party\lua-5.2.3\src\lstring.c (1 hit)
|
|
Line 171: return luaS_newlstr(L, str, strlen(str));
|
|
GitHub\ceph\src\civetweb\src\third_party\lua-5.2.3\src\lstrlib.c (3 hits)
|
|
Line 571: upto += strlen(p + upto) + 1; /* may have more after \0 */
|
|
Line 883: size_t l = strlen(form);
|
|
Line 884: size_t lm = strlen(lenmod);
|
|
GitHub\ceph\src\civetweb\src\third_party\lua-5.2.3\src\lua.c (3 hits)
|
|
Line 187: luai_writestring(LUA_COPYRIGHT, strlen(LUA_COPYRIGHT));
|
|
Line 218: int status = luaL_loadbuffer(L, s, strlen(s), name);
|
|
Line 269: l = strlen(b);
|
|
GitHub\ceph\src\civetweb\src\third_party\lua-5.2.3\src\luaconf.h (1 hit)
|
|
Line 293: #define lua_strlen(L,i) lua_rawlen(L, (i))
|
|
GitHub\ceph\src\civetweb\src\third_party\lua-5.2.3\src\lvm.c (1 hit)
|
|
Line 218: size_t len = strlen(l); /* index of first `\0' in both strings */
|
|
GitHub\ceph\src\civetweb\src\third_party\LuaXML_lib.c (6 hits)
|
|
Line 68: return found ? found-s : strlen(s);
|
|
Line 240: s_size=strlen(s);
|
|
Line 286: tok = Tokenizer_new(str, str_size ? str_size : strlen(str));
|
|
Line 330: lenVal = strlen(aVal)-1;
|
|
Line 388: sv_code[sv_code_size]=(char*)malloc(strlen(decoded)+1);
|
|
Line 390: sv_code[sv_code_size]=(char*)malloc(strlen(encoded)+1);
|
|
GitHub\ceph\src\civetweb\src\third_party\sqlite3.c (207 hits)
|
|
Line 11712: int mxStrlen; /* Maximum string length */
|
|
Line 11851: SQLITE_PRIVATE int sqlite3Strlen30(const char*);
|
|
Line 12762: 0x7ffffffe, /* mxStrlen */
|
|
Line 13225: n = sqlite3Strlen30(zOptName);
|
|
Line 14340: }else if( sqlite3AtoF(zDate, &r, sqlite3Strlen30(zDate), SQLITE_UTF8) ){
|
|
Line 14620: && sqlite3AtoF(&z[8], &r, sqlite3Strlen30(&z[8]), SQLITE_UTF8)
|
|
Line 14706: n = sqlite3Strlen30(z);
|
|
Line 14970: j += sqlite3Strlen30(&z[j]);
|
|
Line 14996: j+=sqlite3Strlen30(&z[j]);
|
|
Line 15004: j += sqlite3Strlen30(&z[j]);
|
|
Line 15013: sqlite3_snprintf(5,&z[j],"%04d",x.Y); j+=sqlite3Strlen30(&z[j]);
|
|
Line 16408: unsigned int n = sqlite3Strlen30(zTitle) + 1;
|
|
Line 19535: n = sqlite3Strlen30(z) + 1;
|
|
Line 20043: length = sqlite3Strlen30(bufpt);
|
|
Line 20188: length = sqlite3Strlen30(bufpt);
|
|
Line 20296: N = sqlite3Strlen30(z);
|
|
Line 21312: SQLITE_PRIVATE int sqlite3Strlen30(const char *z){
|
|
Line 22428: sz = sqlite3Strlen30(z);
|
|
Line 24068: n = (int)strlen(zAbsoluteName);
|
|
Line 26678: for(ii=(int)strlen(zDirname); ii>1 && zDirname[ii]!='/'; ii--);
|
|
Line 27382: nShmFilename = 6 + (int)strlen(pDbFd->zPath);
|
|
Line 28447: nFilename = (int)strlen(zFilename) + 6;
|
|
Line 28556: if( (strlen(zDir) + strlen(SQLITE_TEMP_FILE_PREFIX) + 18) >= (size_t)nBuf ){
|
|
Line 28556: if( (strlen(zDir) + strlen(SQLITE_TEMP_FILE_PREFIX) + 18) >= (size_t)nBuf ){
|
|
Line 28562: j = (int)strlen(zBuf);
|
|
Line 28689: nDb = sqlite3Strlen30(zPath) - 1;
|
|
Line 28825: assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 );
|
|
Line 28838: assert( zName[strlen(zName)+1]==0 );
|
|
Line 29105: nCwd = (int)strlen(zOut);
|
|
Line 29528: dbLen = (int)strlen(dbPath);
|
|
Line 29549: len = (int)strlen(lockPath);
|
|
Line 29977: writeSize = PROXY_PATHINDEX + strlen(&writeBuffer[PROXY_PATHINDEX]);
|
|
Line 30108: int len = (int)strlen(dbPath); /* Length of database filename - dbPath */
|
|
Line 30134: assert( (int)strlen(conchPath) == len+7 );
|
|
Line 30184: assert( (int)strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
|
|
Line 30191: int len = strlen((char *)pFile->lockingContext) - strlen(DOTLOCK_SUFFIX);
|
|
Line 30191: int len = strlen((char *)pFile->lockingContext) - strlen(DOTLOCK_SUFFIX);
|
|
Line 30195: assert( strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
|
|
Line 34096: nName = sqlite3Strlen30(pDbFd->zPath);
|
|
Line 34818: int nLen = sqlite3Strlen30(zBuf);
|
|
Line 35008: nLen = sqlite3Strlen30(zBuf);
|
|
Line 35010: if( (nLen + sqlite3Strlen30(SQLITE_TEMP_FILE_PREFIX) + 18) >= nBuf ){
|
|
Line 35018: j = sqlite3Strlen30(zBuf);
|
|
Line 35166: zUtf8Name[sqlite3Strlen30(zUtf8Name)+1]==0 );
|
|
Line 41231: zJournal += (sqlite3Strlen30(zJournal)+1);
|
|
Line 43308: nPathname = sqlite3Strlen30(zPathname);
|
|
Line 43327: nPathname = sqlite3Strlen30(zPathname);
|
|
Line 43328: z = zUri = &zFilename[sqlite3Strlen30(zFilename)+1];
|
|
Line 43330: z += sqlite3Strlen30(z)+1;
|
|
Line 43331: z += sqlite3Strlen30(z)+1;
|
|
Line 51804: memcpy(zFullPathname, zFilename, sqlite3Strlen30(zFilename)+1);
|
|
Line 59498: pMem->n = sqlite3Strlen30(pMem->z);
|
|
Line 60433: nVal = sqlite3Strlen30(zVal)-1;
|
|
Line 61455: if( n==0 ) n = sqlite3Strlen30(zP4);
|
|
Line 61552: i = sqlite3Strlen30(zTemp);
|
|
Line 61556: int n = sqlite3Strlen30(zColl);
|
|
Line 61909: pMem->n = sqlite3Strlen30(pMem->z);
|
|
Line 61959: pMem->n = sqlite3Strlen30(pMem->z);
|
|
Line 61981: pMem->n = sqlite3Strlen30(pMem->z);
|
|
Line 62486: if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db->aDb[0].pBt))
|
|
Line 62529: nMainFile = sqlite3Strlen30(zMainFile);
|
|
Line 62549: assert( zMaster[sqlite3Strlen30(zMaster)-3]=='9' );
|
|
Line 62582: rc = sqlite3OsWrite(pMaster, zFile, sqlite3Strlen30(zFile)+1, offset);
|
|
Line 62583: offset += sqlite3Strlen30(zFile)+1;
|
|
Line 65219: return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
|
|
Line 65978: zCsr += sqlite3Strlen30(zCsr);
|
|
Line 65980: zCsr += sqlite3Strlen30(zCsr);
|
|
Line 65983: zCsr += sqlite3Strlen30(zCsr);
|
|
Line 65992: zCsr += sqlite3Strlen30(zCsr);
|
|
Line 65995: zCsr += sqlite3Strlen30(zCsr);
|
|
Line 66015: k += sqlite3Strlen30(&zBuf[k]);
|
|
Line 66027: k += sqlite3Strlen30(&zBuf[k]);
|
|
Line 67063: pOp->p1 = sqlite3Strlen30(pOp->p4.z);
|
|
Line 68868: u.as.nName = sqlite3Strlen30(u.as.zName);
|
|
Line 71833: && (sqlite3Strlen30(u.cj.zFilename)==0 /* Temp file */
|
|
Line 71886: pOut->n = sqlite3Strlen30(pOut->z);
|
|
Line 75313: sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8);
|
|
Line 75420: nId = sqlite3Strlen30(zId);
|
|
Line 76267: s.n = sqlite3Strlen30(s.z);
|
|
Line 76648: x.n = zToken ? sqlite3Strlen30(zToken) : 0;
|
|
Line 76801: u32 n = sqlite3Strlen30(z);
|
|
Line 76953: nByte += sqlite3Strlen30(p->u.zToken)+1;
|
|
Line 77018: nToken = sqlite3Strlen30(p->u.zToken) + 1;
|
|
Line 78213: sqlite3AtoF(z, &value, sqlite3Strlen30(z), SQLITE_UTF8);
|
|
Line 78241: c = sqlite3Atoi64(z, &value, sqlite3Strlen30(z), SQLITE_UTF8);
|
|
Line 78615: n = sqlite3Strlen30(z) - 1;
|
|
Line 78830: nId = sqlite3Strlen30(zId);
|
|
Line 80327: pExpr->u.zToken, sqlite3Strlen30(pExpr->u.zToken),
|
|
Line 80838: if( sqlite3Strlen30(zName)>6 && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
|
|
Line 82038: z = zRet + sqlite3Strlen30(zRet);
|
|
Line 82043: z += sqlite3Strlen30(z);
|
|
Line 82084: z += sqlite3Strlen30(z);
|
|
Line 84037: nName = sqlite3Strlen30(zName);
|
|
Line 84127: int nName = sqlite3Strlen30(zName);
|
|
Line 84167: len = sqlite3Strlen30(zIdxName);
|
|
Line 84328: &pIndex->pSchema->idxHash, zName, sqlite3Strlen30(zName), 0
|
|
Line 84372: sqlite3Strlen30(zTabName),0);
|
|
Line 84425: int n = sqlite3Strlen30(zName);
|
|
Line 84427: if( (!OMIT_TEMPDB || i!=1 ) && n==sqlite3Strlen30(pDb->zName) &&
|
|
Line 85234: k = sqlite3Strlen30(zStmt);
|
|
Line 85249: k += sqlite3Strlen30(&zStmt[k]);
|
|
Line 85261: len = sqlite3Strlen30(zType);
|
|
Line 85492: sqlite3Strlen30(p->zName),p);
|
|
Line 86092: nByte += sqlite3Strlen30(pToCol->a[i].zName) + 1;
|
|
Line 86129: int n = sqlite3Strlen30(pToCol->a[i].zName);
|
|
Line 86142: pFKey->zTo, sqlite3Strlen30(pFKey->zTo), (void *)pFKey
|
|
Line 86464: nullId.n = sqlite3Strlen30((char*)nullId.z);
|
|
Line 86478: nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
|
|
Line 86485: nName = sqlite3Strlen30(zName);
|
|
Line 86560: nColl = sqlite3Strlen30(zColl) + 1;
|
|
Line 86648: pIndex->zName, sqlite3Strlen30(pIndex->zName),
|
|
Line 87809: int nName = sqlite3Strlen30(zName);
|
|
Line 87961: int nName = sqlite3Strlen30(pDef->zName);
|
|
Line 89153: sqlite3AtoF(zBuf, &r, sqlite3Strlen30(zBuf), SQLITE_UTF8);
|
|
Line 90361: pDef = sqlite3FindFunction(db, zName, sqlite3Strlen30(zName),
|
|
Line 90406: sqlite3Strlen30(pExpr->u.zToken),
|
|
Line 91136: int nName = sqlite3Strlen30(pTab->zName);
|
|
Line 91626: tToCol.n = sqlite3Strlen30(tToCol.z);
|
|
Line 91627: tFromCol.n = sqlite3Strlen30(tFromCol.z);
|
|
Line 91685: nFrom = sqlite3Strlen30(zFrom);
|
|
Line 91815: sqlite3HashInsert(&pTab->pSchema->fkeyHash, z, sqlite3Strlen30(z), p);
|
|
Line 93892: int nErrMsg = 1 + sqlite3Strlen30(sqlite3_errmsg(db));
|
|
Line 94820: int nMsg = 300 + sqlite3Strlen30(zFile);
|
|
Line 94888: int ncFile = sqlite3Strlen30(zFile);
|
|
Line 94910: nMsg += sqlite3Strlen30(zEntry);
|
|
Line 95614: n = sqlite3Strlen30(z);
|
|
Line 96136: int n = sqlite3Strlen30(zRight);
|
|
Line 96171: sqlite3Atoi64(zRight, &iLimit, sqlite3Strlen30(zRight), SQLITE_UTF8);
|
|
Line 96298: sqlite3Atoi64(zRight, &sz, sqlite3Strlen30(zRight), SQLITE_UTF8);
|
|
Line 97370: if( zRight ) sqlite3_key_v2(db, zDb, zRight, sqlite3Strlen30(zRight));
|
|
Line 97374: if( zRight ) sqlite3_rekey_v2(db, zDb, zRight, sqlite3Strlen30(zRight));
|
|
Line 99711: nName = sqlite3Strlen30(zName);
|
|
Line 101903: sColname.n = sqlite3Strlen30(zColname);
|
|
Line 103266: int n = sqlite3Strlen30(argv[i])+1;
|
|
Line 103557: zName, sqlite3Strlen30(zName)) ){
|
|
Line 103666: nameToken.n = sqlite3Strlen30(nameToken.z);
|
|
Line 103700: pTrig = sqlite3HashInsert(pHash, zName, sqlite3Strlen30(zName), pTrig);
|
|
Line 103705: int n = sqlite3Strlen30(pLink->table);
|
|
Line 103880: nName = sqlite3Strlen30(zName);
|
|
Line 103909: int n = sqlite3Strlen30(pTrigger->table);
|
|
Line 103981: pTrigger = sqlite3HashInsert(pHash, zName, sqlite3Strlen30(zName), 0);
|
|
Line 105602: nName = sqlite3Strlen30(zName);
|
|
Line 105973: pTab->zName, sqlite3Strlen30(pTab->zName) + 1);
|
|
Line 105985: int nName = sqlite3Strlen30(zName);
|
|
Line 106102: nType = sqlite3Strlen30(zType);
|
|
Line 106153: pMod = (Module*)sqlite3HashFind(&db->aModule, zMod, sqlite3Strlen30(zMod));
|
|
Line 106221: pMod = (Module*)sqlite3HashFind(&db->aModule, zMod, sqlite3Strlen30(zMod));
|
|
Line 106564: + sqlite3Strlen30(pDef->zName) + 1);
|
|
Line 106570: memcpy(pNew->zName, pDef->zName, sqlite3Strlen30(pDef->zName)+1);
|
|
Line 108348: pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
|
|
Line 109586: assert( zAff==0 || (int)strlen(zAff)>=nEq );
|
|
Line 110564: int i = sqlite3Strlen30(zName) - 1;
|
|
Line 118833: (255<(nName = sqlite3Strlen30( zFunctionName))) ){
|
|
Line 118999: int nName = sqlite3Strlen30(zName);
|
|
Line 119428: int nName = sqlite3Strlen30(zName);
|
|
Line 119629: int nUri = sqlite3Strlen30(zUri);
|
|
Line 119727: zOpt = &zFile[sqlite3Strlen30(zFile)+1];
|
|
Line 119729: int nOpt = sqlite3Strlen30(zOpt);
|
|
Line 119731: int nVal = sqlite3Strlen30(zVal);
|
|
Line 119777: if( nVal==sqlite3Strlen30(z) && 0==memcmp(zVal, z, nVal) ){
|
|
Line 120676: int n = sqlite3Strlen30(zWord);
|
|
Line 120744: zFilename += sqlite3Strlen30(zFilename) + 1;
|
|
Line 120747: zFilename += sqlite3Strlen30(zFilename) + 1;
|
|
Line 120749: zFilename += sqlite3Strlen30(zFilename) + 1;
|
|
Line 120773: if( z && sqlite3Atoi64(z, &v, sqlite3Strlen30(z), SQLITE_UTF8)==SQLITE_OK ){
|
|
Line 122771: nRet = 2 + (int)strlen(zInput)*2 + 1;
|
|
Line 123027: nStr += (int)strlen(zCol) + 1;
|
|
Line 123038: int n = (int)strlen(zCol)+1;
|
|
Line 123104: assert( strlen(argv[0])==4 );
|
|
Line 123109: nDb = (int)strlen(argv[1]) + 1;
|
|
Line 123110: nName = (int)strlen(argv[2]) + 1;
|
|
Line 123144: && strlen(z)>8
|
|
Line 123183: if( strlen(zVal)!=4 || sqlite3_strnicmp(zVal, "fts3", 4) ){
|
|
Line 123209: if( (strlen(zVal)!=3 || sqlite3_strnicmp(zVal, "asc", 3))
|
|
Line 123210: && (strlen(zVal)!=4 || sqlite3_strnicmp(zVal, "desc", 4))
|
|
Line 123243: nString += (int)(strlen(z) + 1);
|
|
Line 123366: int n = (int)strlen(p->azColumn[iCol]);
|
|
Line 127797: int nDb; /* Result of strlen(zDb) */
|
|
Line 127798: int nFts3; /* Result of strlen(zFts3) */
|
|
Line 127813: nDb = (int)strlen(zDb);
|
|
Line 127817: nDb = (int)strlen(zDb);
|
|
Line 127825: nFts3 = (int)strlen(zFts3);
|
|
Line 128807: int nStr = (int)strlen(zStr);
|
|
Line 129237: n = (int)strlen(z);
|
|
Line 129260: ** nul-terminated string and the length is determined using strlen().
|
|
Line 129661: if( nKey<=0 ) nKey = (int) strlen(z);
|
|
Line 130050: c->nInput = (int)strlen(zInput);
|
|
Line 130496: *pnOut = i = (int)strlen(z);
|
|
Line 130754: zEnd = &zCopy[strlen(zCopy)];
|
|
Line 130760: m = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash,z,(int)strlen(z)+1);
|
|
Line 131159: int i, n = (int)strlen(argv[1]);
|
|
Line 131211: c->nBytes = (int)strlen(pInput);
|
|
Line 131402: int nName = (int)strlen(zName);
|
|
Line 131440: nByte += (int)(strlen(argv[i]) + 1);
|
|
Line 131449: int n = (int)strlen(argv[i]);
|
|
Line 137678: ** determined using strlen().
|
|
Line 137686: nAppend = (int)strlen(zAppend);
|
|
Line 138364: nArg = (int)strlen(zArg);
|
|
Line 138951: int n = strlen(z);
|
|
Line 139003: pCsr->nInput = (int)strlen(aInput);
|
|
Line 140772: || (idxStr && (int)strlen(idxStr)==argc*2) );
|
|
Line 142602: nDb = (int)strlen(argv[1]);
|
|
Line 142603: nName = (int)strlen(argv[2]);
|
|
Line 142698: nCell = (int)strlen(zCell);
|
|
Line 142707: nCell = (int)strlen(zCell);
|
|
Line 143412: n = strlen(argv[0])+1;
|
|
Line 143468: nInput = strlen(zInput);
|
|
GitHub\ceph\src\civetweb\test\embed.c (1 hit)
|
|
Line 67: buf_len = strlen(ri->query_string);
|
|
GitHub\ceph\src\civetweb\test\unit_test.c (23 hits)
|
|
Line 227: *size = strlen(inmemory_file_data);
|
|
Line 269: (int) strlen(upload_ok_message), upload_ok_message);
|
|
Line 384: ASSERT(len1 == (int) strlen(inmemory_file_data));
|
|
Line 393: ASSERT(len1 == (int) strlen(fetch_data));
|
|
Line 462: ASSERT(mg_read(conn, buf, sizeof(buf)) == (int) strlen(upload_ok_message));
|
|
Line 463: ASSERT(memcmp(buf, upload_ok_message, strlen(upload_ok_message)) == 0);
|
|
Line 502: ASSERT(mg_read(conn, buf, sizeof(buf)) == (int) strlen(upload_ok_message));
|
|
Line 503: ASSERT(memcmp(buf, upload_ok_message, strlen(upload_ok_message)) == 0);
|
|
Line 517: base64_encode((unsigned char *) in[i], strlen(in[i]), buf);
|
|
Line 530: ASSERT(mg_get_var(post[0], strlen(post[0]), "a", buf, sizeof(buf)) == 1);
|
|
Line 532: ASSERT(mg_get_var(post[0], strlen(post[0]), "b", buf, sizeof(buf)) == 1);
|
|
Line 534: ASSERT(mg_get_var(post[0], strlen(post[0]), "c", buf, sizeof(buf)) == 2);
|
|
Line 536: ASSERT(mg_get_var(post[0], strlen(post[0]), "e", buf, sizeof(buf)) == 0);
|
|
Line 539: ASSERT(mg_get_var(post[0], strlen(post[0]), "d", buf, sizeof(buf)) == -1);
|
|
Line 540: ASSERT(mg_get_var(post[0], strlen(post[0]), "c", buf, 2) == -2);
|
|
Line 542: ASSERT(mg_get_var(post[0], strlen(post[0]), "x", NULL, 10) == -2);
|
|
Line 543: ASSERT(mg_get_var(post[0], strlen(post[0]), "x", buf, 0) == -2);
|
|
Line 544: ASSERT(mg_get_var(post[1], strlen(post[1]), "st", buf, 16) == -2);
|
|
Line 545: ASSERT(mg_get_var(post[1], strlen(post[1]), "st", buf, 17) == 16);
|
|
Line 597: conn.buf_size = conn.data_len = strlen(http_request);
|
|
Line 798: vec.len = strlen(vec.ptr);
|
|
Line 804: vec.len = strlen(vec.ptr);
|
|
Line 831: md5_append(&md5_state, test_str, strlen(test_str));
|
|
GitHub\ceph\src\client\Client.cc (7 hits)
|
|
Line 6570: dlen = strlen(de->d_name) + 1;
|
|
Line 6742: uint32_t h = ceph_str_hash(CEPH_STR_HASH_RJENKINS, name, strlen(name));
|
|
Line 9210: if (strlen(name) > NAME_MAX)
|
|
Line 9286: if (strlen(name) > NAME_MAX)
|
|
Line 9370: if (strlen(name) > NAME_MAX)
|
|
Line 9443: if (strlen(name) > NAME_MAX)
|
|
Line 9742: if (strlen(newname) > NAME_MAX)
|
|
GitHub\ceph\src\client\SyntheticClient.cc (1 hit)
|
|
Line 1642: tm[strlen(tm)-1] = 0;
|
|
GitHub\ceph\src\client\Trace.cc (2 hits)
|
|
Line 61: strcpy(buf + strlen(prefix),
|
|
Line 62: line.c_str() + strlen("/prefix"));
|
|
GitHub\ceph\src\cls\rbd\cls_rbd.cc (7 hits)
|
|
Line 166: iss.ignore(strlen(RBD_SNAP_KEY_PREFIX)) >> std::hex >> id;
|
|
Line 1742: return key.substr(strlen(RBD_DIR_NAME_KEY_PREFIX));
|
|
Line 2378: return key.substr(strlen(RBD_METADATA_KEY_PREFIX));
|
|
Line 2557: name += strlen(name) + 1;
|
|
Line 2600: for (cur_snap_name = snap_names; cur_snap_name < end; cur_snap_name += strlen(cur_snap_name) + 1) {
|
|
Line 2607: int snap_name_len = strlen(snap_name);
|
|
Line 2679: snap_names += strlen(snap_names) + 1;
|
|
GitHub\ceph\src\cls\rgw\cls_rgw.cc (2 hits)
|
|
Line 338: size_t len = strlen(p);
|
|
Line 352: size_t len = strlen(index_key.c_str());
|
|
GitHub\ceph\src\common\addr_parsing.c (3 hits)
|
|
Line 29: int len2 = strlen(str2);
|
|
Line 96: tok[strlen(tok)-1] == ']') {
|
|
Line 97: tok[strlen(tok)-1] = 0;
|
|
GitHub\ceph\src\common\blkdev.cc (3 hits)
|
|
Line 68: if (strlen(devname) + 1 > out_len) {
|
|
Line 95: if (strlen(de->d_name) + 1 > out_len) {
|
|
Line 145: if (endptr != buff + strlen(buff))
|
|
GitHub\ceph\src\common\ceph_argparse.cc (22 hits)
|
|
Line 164: if (strlen(nextargstr) < 2) {
|
|
Line 170: for (unsigned int i = 0; i < strlen(nextargstr); i++) {
|
|
Line 173: if ((i == 0) && (strlen(nextargstr) >= 2)) {
|
|
Line 201: const char *end = p + strlen(p);
|
|
Line 265: char tmp[strlen(first)+1];
|
|
Line 277: char a2[strlen(a)+1];
|
|
Line 292: char tmp[strlen(first)+1];
|
|
Line 301: int strlen_a = strlen(a);
|
|
Line 301: int strlen_a = strlen(a);
|
|
Line 302: char a2[strlen_a+1];
|
|
Line 304: if (strncmp(a2, first, strlen(a2)) == 0) {
|
|
Line 305: if (first[strlen_a] == '=') {
|
|
Line 307: const char *val = first + strlen_a + 1;
|
|
Line 323: else if (first[strlen_a] == '\0') {
|
|
Line 349: char tmp[strlen(first)+1];
|
|
Line 358: int strlen_a = strlen(a);
|
|
Line 358: int strlen_a = strlen(a);
|
|
Line 359: char a2[strlen_a+1];
|
|
Line 361: if (strncmp(a2, first, strlen(a2)) == 0) {
|
|
Line 362: if (first[strlen_a] == '=') {
|
|
Line 363: *ret = first + strlen_a + 1;
|
|
Line 367: else if (first[strlen_a] == '\0') {
|
|
GitHub\ceph\src\common\config.cc (1 hit)
|
|
Line 785: int l = strlen(str.c_str()) + 1;
|
|
GitHub\ceph\src\common\ConfUtils.cc (3 hits)
|
|
Line 210: char output[strlen(in) + 1];
|
|
Line 214: char *o = output + strlen(output);
|
|
Line 232: char output2[strlen(output) + 1];
|
|
GitHub\ceph\src\common\pick_address.cc (1 hit)
|
|
Line 79: char buf[INET6_ADDRSTRLEN];
|
|
GitHub\ceph\src\common\secret.c (4 hits)
|
|
Line 58: int secret_len = strlen(secret);
|
|
Line 97: int olen = strlen(key_name) + 7;
|
|
Line 99: olen += strlen(secret);
|
|
Line 129: if (strlen(option) + 1 > max_len) {
|
|
GitHub\ceph\src\common\strtol.cc (1 hit)
|
|
Line 139: const char &u = s.at(s.size()-1); //str[std::strlen(str)-1];
|
|
GitHub\ceph\src\common\utf8.c (2 hits)
|
|
Line 165: return check_utf8(buf, strlen(buf));
|
|
Line 186: return check_for_control_characters(buf, strlen(buf));
|
|
GitHub\ceph\src\common\util.cc (4 hits)
|
|
Line 136: if (strncmp(buf, prefix, strlen(prefix))) {
|
|
Line 140: if (buf[strlen(buf)-1] == '\n')
|
|
Line 141: buf[strlen(buf)-1] = '\0';
|
|
Line 143: char *value = buf + strlen(prefix) + 1;
|
|
GitHub\ceph\src\crush\CrushWrapper.cc (5 hits)
|
|
Line 1192: __u32 strlen;
|
|
Line 1193: ::decode(strlen, blp);
|
|
Line 1194: if (strlen == 0) {
|
|
Line 1196: ::decode(strlen, blp);
|
|
Line 1198: ::decode_nohead(strlen, m[key], blp);
|
|
GitHub\ceph\src\erasure-code\jerasure\gf-complete\src\gf_general.c (1 hit)
|
|
Line 150: l = strlen(s);
|
|
GitHub\ceph\src\erasure-code\jerasure\gf-complete\test\gf_unit.c (1 hit)
|
|
Line 120: for (i = 0; i < strlen(argv[2]); i++) {
|
|
GitHub\ceph\src\erasure-code\jerasure\gf-complete\tools\gf_add.c (1 hit)
|
|
Line 34: l = strlen(s);
|
|
GitHub\ceph\src\erasure-code\jerasure\gf-complete\tools\gf_methods.c (2 hits)
|
|
Line 89: if (argv[2][0] != '-' || argv[3][0] != '-' || strlen(argv[2]) == 1 || strlen(argv[3]) != 2) {
|
|
Line 89: if (argv[2][0] != '-' || argv[3][0] != '-' || strlen(argv[2]) == 1 || strlen(argv[3]) != 2) {
|
|
GitHub\ceph\src\erasure-code\jerasure\gf-complete\tools\gf_poly.c (2 hits)
|
|
Line 203: string = (char *) malloc(sizeof(char)*(strlen(argv[i]+100)));
|
|
Line 230: string = (char *) malloc(sizeof(char)*(strlen(argv[i]+100)));
|
|
GitHub\ceph\src\erasure-code\jerasure\jerasure\Examples\decoder.c (5 hits)
|
|
Line 143: cs1 = (char*)malloc(sizeof(char)*strlen(argv[1]));
|
|
Line 159: fname = (char *)malloc(sizeof(char*)*(100+strlen(argv[1])+20));
|
|
Line 169: temp = (char *)malloc(sizeof(char)*(strlen(argv[1])+20));
|
|
Line 183: c_tech = (char *)malloc(sizeof(char)*(strlen(argv[1])+20));
|
|
Line 218: md = strlen(temp);
|
|
GitHub\ceph\src\erasure-code\jerasure\jerasure\Examples\encoder.c (4 hits)
|
|
Line 405: s1 = (char*)malloc(sizeof(char)*(strlen(argv[1])+20));
|
|
Line 423: fname = (char*)malloc(sizeof(char)*(strlen(argv[1])+strlen(curdir)+20));
|
|
Line 423: fname = (char*)malloc(sizeof(char)*(strlen(argv[1])+strlen(curdir)+20));
|
|
Line 425: md = strlen(temp);
|
|
GitHub\ceph\src\erasure-code\jerasure\jerasure\ltmain.sh (19 hits)
|
|
Line 4460: XMALLOC (char, (strlen (actual_cwrapper_path) +
|
|
Line 4461: strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
|
|
Line 4461: strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
|
|
Line 4563: return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
|
|
Line 4690: tmp_len = strlen (tmp);
|
|
Line 4692: XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
|
|
Line 4700: XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
|
|
Line 4716: tmp_len = strlen (tmp);
|
|
Line 4717: concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
|
|
Line 4739: while (strlen (tmp_pathspec) && !has_symlinks)
|
|
Line 4753: p = tmp_pathspec + strlen (tmp_pathspec) - 1;
|
|
Line 4795: len = strlen (str);
|
|
Line 4796: patlen = strlen (pat);
|
|
Line 4866: int len = strlen (name) + 1 + strlen (value) + 1;
|
|
Line 4866: int len = strlen (name) + 1 + strlen (value) + 1;
|
|
Line 4883: int orig_value_len = strlen (orig_value);
|
|
Line 4884: int add_len = strlen (add);
|
|
Line 4915: int len = strlen (new_value);
|
|
Line 4916: while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
|
|
GitHub\ceph\src\erasure-code\jerasure\jerasure\src\jerasure.c (1 hit)
|
|
Line 73: fw = strlen(s);
|
|
GitHub\ceph\src\gmock\gtest\samples\sample2.cc (1 hit)
|
|
Line 42: const size_t len = strlen(a_c_string);
|
|
GitHub\ceph\src\gmock\gtest\samples\sample2.h (1 hit)
|
|
Line 77: return c_string_ == NULL ? 0 : strlen(c_string_);
|
|
GitHub\ceph\src\gmock\gtest\src\gtest-port.cc (2 hits)
|
|
Line 175: const size_t full_regex_len = strlen(regex) + 10;
|
|
Line 429: const size_t len = strlen(regex);
|
|
GitHub\ceph\src\gmock\gtest\src\gtest-printers.cc (1 hit)
|
|
Line 315: PrintCharsAsStringTo(s, strlen(s), os);
|
|
GitHub\ceph\src\gmock\gtest\src\gtest.cc (5 hits)
|
|
Line 842: const int length = strlen(ansi);
|
|
Line 3256: segment = next_segment + strlen("]]>");
|
|
Line 3416: // example, replaces "=" with "%3D". This algorithm is O(strlen(str))
|
|
Line 3421: result.reserve(strlen(str) + 1);
|
|
Line 4664: const size_t prefix_len = strlen(prefix);
|
|
GitHub\ceph\src\gmock\gtest\test\gtest-filepath_test.cc (1 hit)
|
|
Line 524: else if (temp_dir[strlen(temp_dir) - 1] == '\\')
|
|
GitHub\ceph\src\gmock\test\gmock-generated-matchers_test.cc (1 hit)
|
|
Line 469: nested.push_back(list<char>(strings[i], strings[i] + strlen(strings[i])));
|
|
GitHub\ceph\src\gmock\test\gmock-matchers_test.cc (1 hit)
|
|
Line 3746: int operator()(const char* s) { return static_cast<int>(strlen(s)); }
|
|
GitHub\ceph\src\include\encoding.h (1 hit)
|
|
Line 190: __u32 len = strlen(s);
|
|
GitHub\ceph\src\include\rados\librados.h (2 hits)
|
|
Line 365: * @param[out] outstrlen pointer with the size of the reply in outstr
|
|
Line 368: char **outstr, size_t *outstrlen);
|
|
GitHub\ceph\src\include\utime.h (1 hit)
|
|
Line 198: int len = strlen(buf);
|
|
GitHub\ceph\src\java\native\libcephfs_jni.cc (1 hit)
|
|
Line 2895: addressLength = strlen(sun.sun_path);
|
|
GitHub\ceph\src\librados\librados.cc (4 hits)
|
|
Line 2559: char **outstr, size_t *outstrlen)
|
|
Line 2571: if (ret == 0 && !str.empty() && outstr && outstrlen) {
|
|
Line 2572: do_out_buffer(str, outstr, outstrlen);
|
|
Line 2574: tracepoint(librados, rados_ping_monitor_exit, ret, ret < 0 ? NULL : outstr, ret < 0 ? NULL : outstrlen);
|
|
GitHub\ceph\src\librbd\internal.cc (2 hits)
|
|
Line 2717: if ((snap_name != NULL) && (strlen(snap_name) != 0)) {
|
|
Line 2743: snap_name != NULL && strlen(snap_name) != 0) {
|
|
GitHub\ceph\src\librbd\librbd.cc (1 hit)
|
|
Line 1049: names += strlen(names) + 1;
|
|
GitHub\ceph\src\libs3\src\bucket.c (1 hit)
|
|
Line 666: string_buffer_append(queryParams, encoded, strlen(encoded), \
|
|
GitHub\ceph\src\libs3\src\error_parser.c (1 hit)
|
|
Line 92: int nameLen = strlen(elementName);
|
|
GitHub\ceph\src\libs3\src\general.c (1 hit)
|
|
Line 452: S3Status status = simplexml_add(&simpleXml, aclXml, strlen(aclXml));
|
|
GitHub\ceph\src\libs3\src\request.c (3 hits)
|
|
Line 726: strlen(params->bucketContext.secretAccessKey),
|
|
Line 1335: urlEncode(urlEncodedKey, key, strlen(key));
|
|
Line 1370: strlen(bucketContext->secretAccessKey),
|
|
GitHub\ceph\src\libs3\src\service_access_logging.c (1 hit)
|
|
Line 223: S3Status status = simplexml_add(&simpleXml, blsXml, strlen(blsXml));
|
|
GitHub\ceph\src\libs3\src\simplexml.c (1 hit)
|
|
Line 71: int len = strlen(name);
|
|
GitHub\ceph\src\log\Log.cc (1 hit)
|
|
Line 255: int r = safe_write(m_fd, s, strlen(s));
|
|
GitHub\ceph\src\mount\canonicalize.c (3 hits)
|
|
Line 49: npath += strlen(npath);
|
|
Line 119: m = strlen(path);
|
|
Line 164: if (fgets(name, sizeof(name), f) && (sz = strlen(name)) > 1) {
|
|
GitHub\ceph\src\mount\mount.ceph.c (1 hit)
|
|
Line 73: len = strlen(src);
|
|
GitHub\ceph\src\msg\async\AsyncConnection.cc (7 hits)
|
|
Line 987: r = read_until(strlen(CEPH_BANNER), state_buffer);
|
|
Line 995: if (memcmp(state_buffer, CEPH_BANNER, strlen(CEPH_BANNER))) {
|
|
Line 1004: bl.append(state_buffer, strlen(CEPH_BANNER));
|
|
Line 1292: bl.append(CEPH_BANNER, strlen(CEPH_BANNER));
|
|
Line 1328: r = read_until(strlen(CEPH_BANNER) + sizeof(peer_addr), state_buffer);
|
|
Line 1336: if (memcmp(state_buffer, CEPH_BANNER, strlen(CEPH_BANNER))) {
|
|
Line 1342: addr_bl.append(state_buffer+strlen(CEPH_BANNER), sizeof(peer_addr));
|
|
GitHub\ceph\src\msg\msg_types.cc (2 hits)
|
|
Line 92: p = start + strlen(buf4);
|
|
Line 96: p = start + strlen(buf6);
|
|
GitHub\ceph\src\msg\simple\Pipe.cc (9 hits)
|
|
Line 273: char banner[strlen(CEPH_BANNER)+1];
|
|
Line 303: r = tcp_write(CEPH_BANNER, strlen(CEPH_BANNER));
|
|
Line 332: if (tcp_read(banner, strlen(CEPH_BANNER)) < 0) {
|
|
Line 336: if (memcmp(banner, CEPH_BANNER, strlen(CEPH_BANNER))) {
|
|
Line 337: banner[strlen(CEPH_BANNER)] = 0;
|
|
Line 893: char banner[strlen(CEPH_BANNER) + 1]; // extra byte makes coverity happy
|
|
Line 925: if (tcp_read((char*)&banner, strlen(CEPH_BANNER)) < 0) {
|
|
Line 929: if (memcmp(banner, CEPH_BANNER, strlen(CEPH_BANNER))) {
|
|
Line 936: msgvec[0].iov_len = strlen(CEPH_BANNER);
|
|
GitHub\ceph\src\msg\xio\XioMessenger.cc (2 hits)
|
|
Line 225: INET_ADDRSTRLEN);
|
|
Line 229: INET6_ADDRSTRLEN);
|
|
GitHub\ceph\src\objclass\class_api.cc (6 hits)
|
|
Line 96: op.op.cls.class_len = strlen(cls);
|
|
Line 97: op.op.cls.method_len = strlen(method);
|
|
Line 124: op.op.xattr.name_len = strlen(name);
|
|
Line 148: op.op.xattr.name_len = strlen(name);
|
|
Line 288: op.op.xattr.name_len = strlen(name);
|
|
Line 330: op.op.xattr.name_len = strlen(name);
|
|
GitHub\ceph\src\os\chain_xattr.cc (2 hits)
|
|
Line 398: int attr_len = strlen(p);
|
|
Line 448: int attr_len = strlen(p);
|
|
GitHub\ceph\src\os\FileStore.cc (3 hits)
|
|
Line 774: ret = safe_write(fsid_fd, fsid_str, strlen(fsid_str));
|
|
Line 1217: int ret = TEMP_FAILURE_RETRY(::pwrite(fd, s, strlen(s), 0));
|
|
Line 3884: name += strlen(name) + 1;
|
|
GitHub\ceph\src\os\FlatIndex.cc (6 hits)
|
|
Line 74: h.Update((const byte *)filename, strlen(filename));
|
|
Line 91: if (strlen(filename) < FILENAME_PREFIX_LEN)
|
|
Line 109: int len = strlen(filename);
|
|
Line 137: char *t = s + strlen(s);
|
|
Line 170: char *bar = s + strlen(s) - 1;
|
|
Line 210: size_t path_len = strlen(coll_path);
|
|
GitHub\ceph\src\os\KeyValueStore.cc (1 hit)
|
|
Line 636: ret = safe_write(fsid_fd, fsid_str, strlen(fsid_str));
|
|
GitHub\ceph\src\os\LFNIndex.cc (3 hits)
|
|
Line 972: const char *hash = s + strlen(s) - 1;
|
|
Line 1270: h.Update((const byte *)filename, strlen(filename));
|
|
Line 1287: if ((int)strlen(filename) < FILENAME_PREFIX_LEN)
|
|
GitHub\ceph\src\osd\ClassHandler.cc (3 hits)
|
|
Line 55: if (strlen(pde->d_name) > sizeof(CLS_PREFIX) - 1 + sizeof(CLS_SUFFIX) - 1 &&
|
|
Line 57: strcmp(pde->d_name + strlen(pde->d_name) - (sizeof(CLS_SUFFIX) - 1), CLS_SUFFIX) == 0) {
|
|
Line 60: cname[strlen(cname) - (sizeof(CLS_SUFFIX) - 1)] = '\0';
|
|
GitHub\ceph\src\osdc\Objecter.h (7 hits)
|
|
Line 147: osd_op.op.xattr.name_len = (name ? strlen(name) : 0);
|
|
Line 156: osd_op.op.xattr.name_len = (name ? strlen(name) : 0);
|
|
Line 174: osd_op.op.cls.class_len = strlen(cname);
|
|
Line 175: osd_op.op.cls.method_len = strlen(method);
|
|
Line 2233: ops[i].op.xattr.name_len = (name ? strlen(name) : 0);
|
|
Line 2435: ops[i].op.xattr.name_len = (name ? strlen(name) : 0);
|
|
Line 2453: ops[i].op.xattr.name_len = (name ? strlen(name) : 0);
|
|
GitHub\ceph\src\osdc\Striper.cc (1 hit)
|
|
Line 81: char buf[strlen(object_format) + 32];
|
|
GitHub\ceph\src\pybind\rados.py (4 hits)
|
|
Line 463: outstrlen = c_long()
|
|
Line 467: outstrp, byref(outstrlen)))
|
|
Line 469: my_outstr = outstrp.contents[:(outstrlen.value)]
|
|
Line 470: if outstrlen.value:
|
|
GitHub\ceph\src\rbd.cc (11 hits)
|
|
Line 1275: bl.append(RBD_DIFF_BANNER, strlen(RBD_DIFF_BANNER));
|
|
Line 1682: char buf[strlen(RBD_DIFF_BANNER) + 1];
|
|
Line 1683: r = safe_read_exact(fd, buf, strlen(RBD_DIFF_BANNER));
|
|
Line 1686: buf[strlen(RBD_DIFF_BANNER)] = '\0';
|
|
Line 1809: char buf[strlen(RBD_DIFF_BANNER) + 1];
|
|
Line 1810: r = safe_read_exact(fd, buf, strlen(RBD_DIFF_BANNER));
|
|
Line 1814: buf[strlen(RBD_DIFF_BANNER)] = '\0';
|
|
Line 1994: bl.append(RBD_DIFF_BANNER, strlen(RBD_DIFF_BANNER));
|
|
Line 2283: string image_id(prefix + strlen(RBD_DATA_PREFIX));
|
|
Line 2332: header_oid.append(prefix + strlen(RBD_DATA_PREFIX));
|
|
Line 2470: endptr != value_char + strlen(value_char)) {
|
|
GitHub\ceph\src\rbd_fuse\rbd-fuse.cc (6 hits)
|
|
Line 126: for (ip = ibuf; ip < &ibuf[ibuf_len]; ip += strlen(ip) + 1) {
|
|
Line 128: ((strlen(mount_image_name) > 0) &&
|
|
Line 628: if (value != NULL && size >= strlen(buf))
|
|
Line 631: return (strlen(buf));
|
|
Line 647: required_len += strlen(ap->attrname) + 1;
|
|
Line 651: list += strlen(ap->attrname) + 1;
|
|
GitHub\ceph\src\rgw\librgw.cc (1 hit)
|
|
Line 92: if (!parser.parse(xml, strlen(xml), true)) {
|
|
GitHub\ceph\src\rgw\rgw_civetweb.cc (1 hit)
|
|
Line 93: int len = strlen(header->name) + 5; /* HTTP_ prepended */
|
|
GitHub\ceph\src\rgw\rgw_common.cc (2 hits)
|
|
Line 195: snprintf(buf + strlen(buf), sizeof(buf)-strlen(buf) ,":%03ld", timetest.tv_usec/1000);
|
|
Line 195: snprintf(buf + strlen(buf), sizeof(buf)-strlen(buf) ,":%03ld", timetest.tv_usec/1000);
|
|
GitHub\ceph\src\rgw\rgw_env.cc (1 hit)
|
|
Line 109: return (strncmp(iter->first.c_str(), prefix, strlen(prefix)) == 0);
|
|
GitHub\ceph\src\rgw\rgw_formats.cc (1 hit)
|
|
Line 221: len = pos + strlen(p) + 1;
|
|
GitHub\ceph\src\rgw\rgw_op.cc (4 hits)
|
|
Line 1772: supplied_md5_b64, supplied_md5_b64 + strlen(supplied_md5_b64));
|
|
Line 1898: manifest_bl.append(obj_manifest, strlen(obj_manifest) + 1);
|
|
Line 2100: if (name.compare(0, strlen(RGW_ATTR_META_PREFIX), RGW_ATTR_META_PREFIX) == 0) {
|
|
Line 3229: etag_bl.append(final_etag_str, strlen(final_etag_str) + 1);
|
|
GitHub\ceph\src\rgw\rgw_rest.cc (2 hits)
|
|
Line 356: if ( (strlen(key) > 0) && (strlen(value) > 0))
|
|
Line 356: if ( (strlen(key) > 0) && (strlen(value) > 0))
|
|
GitHub\ceph\src\rgw\rgw_rest_swift.cc (2 hits)
|
|
Line 519: const size_t put_prefix_len = strlen(put_prefix);
|
|
Line 520: const size_t del_prefix_len = strlen(del_prefix);
|
|
GitHub\ceph\src\rgw\rgw_swift.cc (1 hit)
|
|
Line 96: char url_buf[auth_url.size() + 1 + strlen(token) + 1];
|
|
GitHub\ceph\src\rgw\rgw_swift_auth.cc (1 hit)
|
|
Line 69: int len = strlen(token);
|
|
GitHub\ceph\src\rocksdb\db\corruption_test.cc (1 hit)
|
|
Line 218: storage->assign(buf, strlen(buf));
|
|
GitHub\ceph\src\rocksdb\db\c_test.c (6 hits)
|
|
Line 46: } else if (expected != NULL && v != NULL && n == strlen(expected) &&
|
|
Line 74: val = rocksdb_get(db, options, key, strlen(key), &val_len, &err);
|
|
Line 89: val = rocksdb_get_cf(db, options, handle, key, strlen(key), &val_len, &err);
|
|
Line 256: len = strlen("changed");
|
|
Line 523: rocksdb_put(db, woptions, keybuf, strlen(keybuf), valbuf, strlen(valbuf),
|
|
Line 523: rocksdb_put(db, woptions, keybuf, strlen(keybuf), valbuf, strlen(valbuf),
|
|
GitHub\ceph\src\rocksdb\db\db_bench.cc (6 hits)
|
|
Line 1278: strlen(text), &compressed);
|
|
Line 1283: strlen(text), &compressed);
|
|
Line 1288: strlen(text), &compressed);
|
|
Line 1293: strlen(text), &compressed);
|
|
Line 1298: strlen(text), &compressed);
|
|
Line 1308: } else if (name && compressed.size() >= strlen(text)) {
|
|
GitHub\ceph\src\rocksdb\db\fault_injection_test.cc (1 hit)
|
|
Line 596: storage->assign(buf, strlen(buf));
|
|
GitHub\ceph\src\rocksdb\db\filename.cc (2 hits)
|
|
Line 236: rest.remove_prefix(strlen("MANIFEST-"));
|
|
Line 247: rest.remove_prefix(strlen("METADB-"));
|
|
GitHub\ceph\src\rocksdb\db\internal_stats.cc (1 hit)
|
|
Line 177: in.remove_prefix(strlen("rocksdb.num-files-at-level"));
|
|
GitHub\ceph\src\rocksdb\examples\c_simple_example.c (3 hits)
|
|
Line 38: rocksdb_put(db, writeoptions, key, strlen(key), value, strlen(value) + 1,
|
|
Line 38: rocksdb_put(db, writeoptions, key, strlen(key), value, strlen(value) + 1,
|
|
Line 45: rocksdb_get(db, readoptions, key, strlen(key), &len, &err);
|
|
GitHub\ceph\src\rocksdb\include\rocksdb\slice.h (2 hits)
|
|
Line 41: // Create a slice that refers to s[0,strlen(s)-1]
|
|
Line 43: Slice(const char* s) : data_(s), size_(strlen(s)) { }
|
|
GitHub\ceph\src\rocksdb\java\rocksjni\slice.cc (1 hit)
|
|
Line 31: const size_t len = strlen(str);
|
|
GitHub\ceph\src\rocksdb\port\stack_trace.cc (2 hits)
|
|
Line 63: line[strlen(line) - 1] = 0; // remove newline
|
|
Line 86: line[strlen(line) - 1] = 0; // remove newline
|
|
GitHub\ceph\src\rocksdb\third-party\fbson\FbsonDocument.h (2 hits)
|
|
Line 333: return findPath(key_path, (unsigned int)strlen(key_path), delim, handler);
|
|
Line 542: return find(key, (unsigned int)strlen(key), handler);
|
|
GitHub\ceph\src\rocksdb\third-party\fbson\FbsonJsonParser.h (1 hit)
|
|
Line 111: return parse(c_str, (unsigned int)strlen(c_str), handler);
|
|
GitHub\ceph\src\rocksdb\third-party\fbson\FbsonStream.h (1 hit)
|
|
Line 94: void write(const char* c_str) { write(c_str, (uint32_t)strlen(c_str)); }
|
|
GitHub\ceph\src\rocksdb\third-party\gtest-1.7.0\fused-src\gtest\gtest-all.cc (8 hits)
|
|
Line 2298: const int length = strlen(ansi);
|
|
Line 5008: segment = next_segment + strlen("]]>");
|
|
Line 5168: // example, replaces "=" with "%3D". This algorithm is O(strlen(str))
|
|
Line 5173: result.reserve(strlen(str) + 1);
|
|
Line 6409: const size_t prefix_len = strlen(prefix);
|
|
Line 9037: const size_t full_regex_len = strlen(regex) + 10;
|
|
Line 9291: const size_t len = strlen(regex);
|
|
Line 9985: PrintCharsAsStringTo(s, strlen(s), os);
|
|
GitHub\ceph\src\rocksdb\util\benchharness.cc (1 hit)
|
|
Line 318: longestName = max(longestName, strlen(get<1>(benchmarks[i])));
|
|
GitHub\ceph\src\rocksdb\util\ldb_cmd.cc (2 hits)
|
|
Line 341: *value = line.substr(pos + strlen(DELIM));
|
|
Line 599: && match == strlen(entry->d_name)) {
|
|
GitHub\ceph\src\rocksdb\utilities\spatialdb\spatial_db.cc (1 hit)
|
|
Line 60: dst->remove_prefix(8); // strlen("spatial$")
|
|
GitHub\ceph\src\test\barclass.cc (2 hits)
|
|
Line 26: for (i=0; i<strlen(indata) + 1; i++) {
|
|
Line 33: *outdatalen = strlen(*outdata) + 1;
|
|
GitHub\ceph\src\test\base64.cc (2 hits)
|
|
Line 28: int alen = ceph_armor(out, out + OUT_LEN, original, original + strlen(original));
|
|
Line 81: int alen = ceph_unarmor(out, out + OUT_LEN, bad_encoded, bad_encoded + strlen(bad_encoded));
|
|
GitHub\ceph\src\test\bufferlist.cc (15 hits)
|
|
Line 627: const bufferptr ptr(buffer::create_static(strlen(in), in));
|
|
Line 628: EXPECT_THROW(ptr.copy_out((unsigned)0, strlen(in) + 1, NULL), buffer::end_of_buffer);
|
|
Line 629: EXPECT_THROW(ptr.copy_out(strlen(in) + 1, (unsigned)0, NULL), buffer::end_of_buffer);
|
|
Line 644: EXPECT_THROW(ptr.copy_in((unsigned)0, strlen(in) + 1, NULL), FailedAssertion);
|
|
Line 645: EXPECT_THROW(ptr.copy_in(strlen(in) + 1, (unsigned)0, NULL), FailedAssertion);
|
|
Line 674: bufferptr ptr(buffer::create_static(strlen(str), str));
|
|
Line 693: bufferptr ptr(buffer::create_static(strlen(str), str));
|
|
Line 1824: bufferptr ptr(s[i], strlen(s[i]));
|
|
Line 1847: bufferptr ptr(s[i], strlen(s[i]));
|
|
Line 1896: EXPECT_EQ(0, ::memcmp(expected, other.c_str(), strlen(expected)));
|
|
Line 1905: EXPECT_EQ(0, ::memcmp(expected, other.c_str(), strlen(expected)));
|
|
Line 2210: bufferptr ptr(s[i], strlen(s[i]));
|
|
Line 2242: bufferptr ptr(s[0], strlen(s[0]));
|
|
Line 2250: bufferptr ptr(s[i], strlen(s[i]));
|
|
Line 2260: bufferptr ptr(s[i], strlen(s[i]));
|
|
GitHub\ceph\src\test\cls_rbd\test_cls_rbd.cc (1 hit)
|
|
Line 1226: pairs[key].append(val, strlen(val));
|
|
GitHub\ceph\src\test\common\test_blkdev.cc (1 hit)
|
|
Line 62: if (strncmp(de2->d_name, de->d_name, strlen(de->d_name))) {
|
|
GitHub\ceph\src\test\common\test_crc32c.cc (4 hits)
|
|
Line 21: ASSERT_EQ(4119623852u, ceph_crc32c(0, (unsigned char *)a, strlen(a)));
|
|
Line 22: ASSERT_EQ(881700046u, ceph_crc32c(1234, (unsigned char *)a, strlen(a)));
|
|
Line 23: ASSERT_EQ(2360230088u, ceph_crc32c(0, (unsigned char *)b, strlen(b)));
|
|
Line 24: ASSERT_EQ(3743019208u, ceph_crc32c(5678, (unsigned char *)b, strlen(b)));
|
|
GitHub\ceph\src\test\confutils.cc (9 hits)
|
|
Line 89: size_t strlen_text = strlen(text);
|
|
Line 89: size_t strlen_text = strlen(text);
|
|
Line 90: size_t res = fwrite(text, 1, strlen_text, fp);
|
|
Line 91: if (res != strlen_text) {
|
|
Line 320: bl3.append(trivial_conf_3, strlen(trivial_conf_3));
|
|
Line 349: bl3.append(simple_conf_1, strlen(simple_conf_1));
|
|
Line 355: bl4.append(simple_conf_2, strlen(simple_conf_2));
|
|
Line 382: bl2.append(simple_conf_2, strlen(simple_conf_2));
|
|
Line 424: bl2.append(illegal_conf2, strlen(illegal_conf2));
|
|
GitHub\ceph\src\test\erasure-code\TestErasureCodeExample.cc (1 hit)
|
|
Line 182: in_ptr.append(payload, strlen(payload));
|
|
GitHub\ceph\src\test\erasure-code\TestErasureCodeIsa.cc (4 hits)
|
|
Line 443: in_ptr.append(payload, strlen(payload));
|
|
Line 570: in_ptr.append(payload, strlen(payload));
|
|
Line 697: in_ptr.append(payload, strlen(payload));
|
|
Line 823: in_ptr.append(payload, strlen(payload));
|
|
GitHub\ceph\src\test\erasure-code\TestErasureCodeJerasure.cc (1 hit)
|
|
Line 81: in_ptr.append(payload, strlen(payload));
|
|
GitHub\ceph\src\test\erasure-code\TestErasureCodePluginJerasure.cc (1 hit)
|
|
Line 184: in_ptr.append(payload, strlen(payload));
|
|
GitHub\ceph\src\test\escape.cc (1 hit)
|
|
Line 59: int src_len = strlen(str);
|
|
GitHub\ceph\src\test\fooclass.cc (2 hits)
|
|
Line 26: for (i=0; i<strlen(indata) + 1; i++) {
|
|
Line 33: *outdatalen = strlen(*outdata) + 1;
|
|
GitHub\ceph\src\test\libcephfs\test.cc (17 hits)
|
|
Line 460: len -= strlen(p) + 1;
|
|
Line 461: p += strlen(p) + 1;
|
|
Line 519: res = ceph_ll_setxattr(cmount, existent_file_handle, valid_name, value, strlen(value), 0, 0, 0);
|
|
Line 523: ASSERT_EQ(res, (int)strlen(value));
|
|
Line 561: ASSERT_EQ(ceph_write(cmount, fd, bytes, strlen(bytes), 0), (int)strlen(bytes));
|
|
Line 561: ASSERT_EQ(ceph_write(cmount, fd, bytes, strlen(bytes), 0), (int)strlen(bytes));
|
|
Line 576: ASSERT_EQ(ret, (int)strlen(bytes));
|
|
Line 580: ASSERT_EQ(ceph_write(cmount, fd, bytes, strlen(bytes), 0), -EBADF);
|
|
Line 595: ASSERT_EQ(ceph_write(cmount, fd, bytes, strlen(bytes), 0), (int)strlen(bytes));
|
|
Line 595: ASSERT_EQ(ceph_write(cmount, fd, bytes, strlen(bytes), 0), (int)strlen(bytes));
|
|
Line 616: ASSERT_EQ(ceph_write(cmount, fd, bytes, strlen(bytes), 0), (int)strlen(bytes));
|
|
Line 616: ASSERT_EQ(ceph_write(cmount, fd, bytes, strlen(bytes), 0), (int)strlen(bytes));
|
|
Line 623: ASSERT_EQ(ret, (int)strlen(bytes));
|
|
Line 627: ASSERT_EQ(ceph_write(cmount, fd, bytes, strlen(bytes), 0), (int)strlen(bytes));
|
|
Line 627: ASSERT_EQ(ceph_write(cmount, fd, bytes, strlen(bytes), 0), (int)strlen(bytes));
|
|
Line 639: ASSERT_EQ(ceph_write(cmount, fd, bytes, strlen(bytes), 0), (int)strlen(bytes));
|
|
Line 639: ASSERT_EQ(ceph_write(cmount, fd, bytes, strlen(bytes), 0), (int)strlen(bytes));
|
|
GitHub\ceph\src\test\librados\c_read_operations.cc (1 hit)
|
|
Line 13: const int len = strlen(data);
|
|
GitHub\ceph\src\test\librados\lock.cc (6 hits)
|
|
Line 124: ASSERT_EQ(strlen("Tag") + 1, tag_len);
|
|
Line 128: ASSERT_EQ(strlen("Cookie") + 1, cookies_len);
|
|
Line 177: ASSERT_EQ(strlen("Cookie") + 1, cookies_len);
|
|
Line 303: ASSERT_EQ(strlen("Tag") + 1, tag_len);
|
|
Line 307: ASSERT_EQ(strlen("Cookie") + 1, cookies_len);
|
|
Line 356: ASSERT_EQ(strlen("Cookie") + 1, cookies_len);
|
|
GitHub\ceph\src\test\librados\pool.cc (1 hit)
|
|
Line 23: buf += strlen(buf) + 1;
|
|
GitHub\ceph\src\test\librados\stat.cc (2 hits)
|
|
Line 111: ASSERT_EQ(strlen(actual_pool_name), l);
|
|
Line 227: ASSERT_EQ(strlen(actual_pool_name), l);
|
|
GitHub\ceph\src\test\librbd\fsx.cc (2 hits)
|
|
Line 2126: if (strlen(goodfile) < sizeof(goodfile)-2) {
|
|
Line 2134: if (strlen(logfile) < sizeof(logfile)-2) {
|
|
GitHub\ceph\src\test\librbd\test_librbd.cc (47 hits)
|
|
Line 338: cur_name += strlen(cur_name) + 1;
|
|
Line 976: bl.append(test_data, strlen(test_data));
|
|
Line 980: image.aio_write2(off, strlen(test_data), bl, comp, iohint);
|
|
Line 982: image.aio_write(off, strlen(test_data), bl, comp);
|
|
Line 1007: size_t len = strlen(test_data);
|
|
Line 1095: ASSERT_PASSED(write_test_data, image, test_data, strlen(test_data) * i, 0);
|
|
Line 1098: ASSERT_PASSED(aio_write_test_data, image, test_data, strlen(test_data) * i, 0);
|
|
Line 1101: ASSERT_PASSED(read_test_data, image, test_data, strlen(test_data) * i, TEST_IO_SIZE, 0);
|
|
Line 1104: ASSERT_PASSED(aio_read_test_data, image, test_data, strlen(test_data) * i, TEST_IO_SIZE, 0);
|
|
Line 1146: ASSERT_PASSED(write_test_data, image, test_data, strlen(test_data) * i,
|
|
Line 1150: ASSERT_PASSED(aio_write_test_data, image, test_data, strlen(test_data) * i,
|
|
Line 1153: ASSERT_PASSED(read_test_data, image, test_data, strlen(test_data),
|
|
Line 1157: ASSERT_PASSED(aio_read_test_data, image, test_data, strlen(test_data) * i,
|
|
Line 1276: ASSERT_EQ((ssize_t)strlen(data), rbd_write(parent, 0, strlen(data), data));
|
|
Line 1276: ASSERT_EQ((ssize_t)strlen(data), rbd_write(parent, 0, strlen(data), data));
|
|
Line 1311: ASSERT_PASSED(read_test_data, child, data, 0, strlen(data), 0);
|
|
Line 1314: ASSERT_EQ((ssize_t)strlen(data), rbd_write(child, 20, strlen(data), data));
|
|
Line 1314: ASSERT_EQ((ssize_t)strlen(data), rbd_write(child, 20, strlen(data), data));
|
|
Line 1315: ASSERT_PASSED(read_test_data, child, data, 20, strlen(data), 0);
|
|
Line 1316: ASSERT_PASSED(read_test_data, child, data, 0, strlen(data), 0);
|
|
Line 1392: ASSERT_EQ((ssize_t)strlen(data), rbd_write(parent, 0, strlen(data), data));
|
|
Line 1392: ASSERT_EQ((ssize_t)strlen(data), rbd_write(parent, 0, strlen(data), data));
|
|
Line 1393: ASSERT_EQ((ssize_t)strlen(data), rbd_write(parent, 12, strlen(data), data));
|
|
Line 1393: ASSERT_EQ((ssize_t)strlen(data), rbd_write(parent, 12, strlen(data), data));
|
|
Line 1428: ASSERT_EQ((ssize_t)strlen(childata), rbd_write(child, 20, strlen(childata), childata));
|
|
Line 1428: ASSERT_EQ((ssize_t)strlen(childata), rbd_write(child, 20, strlen(childata), childata));
|
|
Line 1430: char test[strlen(data) * 2];
|
|
Line 1431: ASSERT_EQ((ssize_t)strlen(data), rbd_read(child, 20, strlen(data), test));
|
|
Line 1431: ASSERT_EQ((ssize_t)strlen(data), rbd_read(child, 20, strlen(data), test));
|
|
Line 1432: ASSERT_EQ(0, memcmp(test, childata, strlen(childata)));
|
|
Line 1435: ASSERT_EQ((ssize_t)sizeof(test), rbd_read(child, 20 - strlen(data), sizeof(test), test));
|
|
Line 1436: ASSERT_EQ(0, memcmp(test, data, strlen(data)));
|
|
Line 1437: ASSERT_EQ(0, memcmp(test + strlen(data), childata, strlen(childata)));
|
|
Line 1437: ASSERT_EQ(0, memcmp(test + strlen(data), childata, strlen(childata)));
|
|
Line 1441: ASSERT_EQ(0, memcmp(test, data, strlen(data)));
|
|
Line 1524: const char *block_name_suffix = entry + strlen(p_info.block_name_prefix) + 1;
|
|
Line 1575: const char *block_name_suffix = entry + strlen(c_info.block_name_prefix) + 1;
|
|
Line 1624: pool += strlen(pool) + 1;
|
|
Line 1625: image += strlen(image) + 1;
|
|
Line 1977: bls[i].append(test_data, strlen(test_data));
|
|
Line 2447: char read_data[strlen(data)];
|
|
Line 2448: ASSERT_EQ((int)strlen(data), rbd_write(image, 0, strlen(data), data));
|
|
Line 2448: ASSERT_EQ((int)strlen(data), rbd_write(image, 0, strlen(data), data));
|
|
Line 2450: ASSERT_EQ((int)strlen(data), rbd_read(image, 0, strlen(data), read_data));
|
|
Line 2450: ASSERT_EQ((int)strlen(data), rbd_read(image, 0, strlen(data), read_data));
|
|
Line 2451: ASSERT_EQ(0, memcmp(data, read_data, strlen(data)));
|
|
Line 2967: std::string image_id(prefix + strlen(RBD_DATA_PREFIX));
|
|
GitHub\ceph\src\test\msgr\test_async_driver.cc (2 hits)
|
|
Line 237: r = write(client_sd, data, strlen(data));
|
|
Line 238: ASSERT_EQ(r, (int)strlen(data));
|
|
GitHub\ceph\src\test\objectstore\chain_xattr.cc (3 hits)
|
|
Line 170: for (char *p = attrbuf; p - attrbuf < l; p += strlen(p) + 1) {
|
|
Line 178: for (char *p = attrbuf; p - attrbuf < l; p += strlen(p) + 1) {
|
|
Line 194: for (char *p = attrbuf; p - attrbuf < l; p += strlen(p) + 1) {
|
|
GitHub\ceph\src\test\objectstore\store_test.cc (1 hit)
|
|
Line 1270: bufferptr bp(buf, strlen(buf) + 1);
|
|
GitHub\ceph\src\test\testclass.cc (2 hits)
|
|
Line 26: for (i=0; i<strlen(indata) + 1; i++) {
|
|
Line 33: *outdatalen = strlen(*outdata) + 1;
|
|
GitHub\ceph\src\test\testcrypto.cc (2 hits)
|
|
Line 21: bufferptr ptr(msg, strlen(msg));
|
|
Line 24: enc_in.append(msg, strlen(msg));
|
|
GitHub\ceph\src\test\testkeys.cc (2 hits)
|
|
Line 32: bufferptr ptr(msg, strlen(msg));
|
|
Line 35: enc_in.append(msg, strlen(msg));
|
|
GitHub\ceph\src\test\test_arch.cc (1 hit)
|
|
Line 46: flags[strlen(flags) - 1] = ' ';
|
|
GitHub\ceph\src\test\test_filejournal.cc (4 hits)
|
|
Line 87: size_t copy_len = std::min(sizeof(path) - 1, strlen(args[i]));
|
|
Line 342: for (unsigned o=0; o < sizeof(buf) - strlen(needle); o++) {
|
|
Line 343: if (memcmp(buf+o, needle, strlen(needle)) == 0) {
|
|
Line 346: memcpy(buf+o, newneedle, strlen(newneedle));
|
|
GitHub\ceph\src\test\test_rewrite_latency.cc (1 hit)
|
|
Line 27: int r = ::pwrite(fd, fn, strlen(fn), 0);
|
|
GitHub\ceph\src\test\test_rgw_admin_log.cc (1 hit)
|
|
Line 714: uint32_t r = ceph_str_hash_linux(bucket_name, strlen(bucket_name)) % max_shards;
|
|
GitHub\ceph\src\test\utf8.cc (1 hit)
|
|
Line 24: ASSERT_EQ(0, check_utf8("foo", strlen("foo")));
|
|
GitHub\ceph\src\tools\ceph_objectstore_tool.cc (1 hit)
|
|
Line 2002: format = format.substr(0, format.size() - strlen("-pretty"));
|
|
GitHub\ceph\src\tools\radosacl.cc (1 hit)
|
|
Line 144: bl.append(buf, strlen(buf));
|
|
GitHub\ceph\src\tools\scratchtool.c (6 hits)
|
|
Line 26: int ret = rados_setxattr(io_ctx, oid, key, val, strlen(val) + 1);
|
|
Line 38: size_t blen = strlen(expected) + 1;
|
|
Line 83: if ((len == strlen(exvals[i]) + 1) && (!strcmp(exvals[i], val))) {
|
|
Line 188: b += strlen(b) + 1;
|
|
Line 221: r = rados_write(io_ctx, oid, buf, strlen(buf) + 1, 0);
|
|
Line 254: rados_exec(io_ctx, oid, "crypto", "md5", buf, strlen(buf) + 1, buf, 128);
|
|
GitHub\ceph\src\tools\scratchtoolpp.cc (2 hits)
|
|
Line 103: bl.append(buf, strlen(buf));
|
|
Line 238: for (int i=0; i<r; i++, s += strlen(s) + 1)
|
|
Search "snprintf(s" (66 hits in 21 files)
|
|
GitHub\ceph\src\ceph_mds.cc (1 hit)
|
|
Line 248: snprintf(s, sizeof(s), "gmon/%d", getpid());
|
|
GitHub\ceph\src\ceph_mon.cc (1 hit)
|
|
Line 787: snprintf(s, sizeof(s), "gmon/%d", getpid());
|
|
GitHub\ceph\src\ceph_osd.cc (1 hit)
|
|
Line 608: snprintf(s, sizeof(s), "gmon/%d", getpid());
|
|
GitHub\ceph\src\civetweb\examples\chat\chat.c (1 hit)
|
|
Line 290: snprintf(session->random, sizeof(session->random), "%d", rand());
|
|
GitHub\ceph\src\civetweb\examples\ws_server\ws_server.c (1 hit)
|
|
Line 250: snprintf(server_name, sizeof(server_name),
|
|
GitHub\ceph\src\civetweb\src\civetweb.c (3 hits)
|
|
Line 1002: static int mg_vsnprintf(struct mg_connection *conn, char *buf, size_t buflen,
|
|
Line 1025: static int mg_snprintf(struct mg_connection *conn, char *buf, size_t buflen,
|
|
Line 1029: static int mg_snprintf(struct mg_connection *conn, char *buf, size_t buflen,
|
|
GitHub\ceph\src\civetweb\src\main.c (1 hit)
|
|
Line 411: snprintf(server_base_name, sizeof(server_base_name), "Civetweb V%s",
|
|
GitHub\ceph\src\civetweb\src\third_party\sqlite3.c (22 hits)
|
|
Line 14831: sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d %02d:%02d:%02d",
|
|
Line 14851: sqlite3_snprintf(sizeof(zBuf), zBuf, "%02d:%02d:%02d", x.h, x.m, (int)x.s);
|
|
Line 14870: sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d", x.Y, x.M, x.D);
|
|
Line 29735: sqlite3_snprintf(sizeof(errmsg),errmsg,"path error (len %d)",(int)pathLen);
|
|
Line 29741: sqlite3_snprintf(sizeof(errmsg),errmsg,"read error (len %d)",(int)readLen);
|
|
Line 29747: sqlite3_snprintf(sizeof(errmsg), errmsg, "create failed (%d)", errno);
|
|
Line 29751: sqlite3_snprintf(sizeof(errmsg), errmsg, "write failed (%d)", errno);
|
|
Line 29755: sqlite3_snprintf(sizeof(errmsg), errmsg, "rename failed (%d)", errno);
|
|
Line 46697: sqlite3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]",
|
|
Line 57945: sqlite3_snprintf(sizeof(zContext), zContext, "Page %d: ", iPage);
|
|
Line 57980: sqlite3_snprintf(sizeof(zContext), zContext,
|
|
Line 58029: sqlite3_snprintf(sizeof(zContext), zContext,
|
|
Line 62031: sqlite3_snprintf(sizeof(z), z, "%s", pOp->p4.z);
|
|
Line 83207: sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
|
|
Line 83211: sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
|
|
Line 83215: sqlite3_snprintf(sizeof(zErr), zErr,
|
|
Line 83220: sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
|
|
Line 85854: sqlite3_snprintf(sizeof(zTab),zTab,"sqlite_stat%d",i);
|
|
Line 89711: sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.15g", r1);
|
|
Line 89714: sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.20e", r1);
|
|
Line 118618: sqlite3_snprintf(sizeof(zBuf), zBuf, "SQLITE_UNKNOWN(%d)", origRc);
|
|
Line 138642: sqlite3_snprintf(sizeof(aBuffer), aBuffer,
|
|
GitHub\ceph\src\client\SyntheticClient.cc (5 hits)
|
|
Line 300: snprintf(s, sizeof(s), "syn.%lld.%d", (long long)client->whoami.v, seq);
|
|
Line 3007: snprintf(src, sizeof(src), "syn.0.0/dir.%d/dir.%d/file.%d", a, b, c);
|
|
Line 3027: snprintf(src, sizeof(src), "syn.0.0/dir.%d/dir.%d/file.%d", a, b, c);
|
|
Line 3047: snprintf(src, sizeof(src), "syn.0.0/dir.%d/dir.%d/file.%d", a, b, c);
|
|
Line 3062: snprintf(src, sizeof(src), "syn.0.0/dir.%d/dir.%d/file.%d", a, b, c);
|
|
GitHub\ceph\src\client\SyntheticClient.h (1 hit)
|
|
Line 163: snprintf(sub_s, sizeof(sub_s), "%s.%d", base, rand() % 100);
|
|
GitHub\ceph\src\crush\CrushCompiler.cc (1 hit)
|
|
Line 55: snprintf(s, sizeof(s), "%.3f", (float)i / (float)0x10000);
|
|
GitHub\ceph\src\crush\CrushWrapper.cc (1 hit)
|
|
Line 1307: snprintf(str, sizeof(str), "unsupported bucket algorithm: %d", alg);
|
|
GitHub\ceph\src\include\CompatSet.h (1 hit)
|
|
Line 115: snprintf(s, sizeof(s), "feature_%lld", (unsigned long long)p->first);
|
|
GitHub\ceph\src\mds\CInode.cc (1 hit)
|
|
Line 846: snprintf(s, sizeof(s), "%llx", (unsigned long long)inode.ino.val);
|
|
GitHub\ceph\src\mds\MDCache.cc (2 hits)
|
|
Line 11425: snprintf(s, sizeof(s), "%2d ", int(dir->get_dir_auth().first));
|
|
Line 11427: snprintf(s, sizeof(s), "%2d,%2d", int(dir->get_dir_auth().first), int(dir->get_dir_auth().second));
|
|
GitHub\ceph\src\mds\SessionMap.cc (1 hit)
|
|
Line 66: snprintf(s, sizeof(s), "mds%d_sessionmap", int(mds->whoami));
|
|
GitHub\ceph\src\os\BtrfsFileStoreBackend.cc (2 hits)
|
|
Line 439: snprintf(s, sizeof(s), "%s/current.remove.me.%d", get_basedir_path().c_str(), rand());
|
|
Line 448: snprintf(s, sizeof(s), "%s/%s", get_basedir_path().c_str(), name.c_str());
|
|
GitHub\ceph\src\os\FileStore.cc (8 hits)
|
|
Line 151: return snprintf(s, len, "%s/current/%s", basedir.c_str(), cid_str.c_str());
|
|
Line 854: snprintf(s, sizeof(s), COMMIT_SNAP_ITEM, 1ull);
|
|
Line 1216: snprintf(s, sizeof(s), "%" PRId64 "\n", seq);
|
|
Line 1369: snprintf(s, sizeof(s), CLUSTER_SNAP_ITEM, m_osd_rollback_to_cluster_snap.c_str());
|
|
Line 1405: snprintf(s, sizeof(s), COMMIT_SNAP_ITEM, (long long unsigned)cp);
|
|
Line 3601: snprintf(s, sizeof(s), COMMIT_SNAP_ITEM, (long long unsigned)cp);
|
|
Line 3665: snprintf(s, sizeof(s), COMMIT_SNAP_ITEM, (long long unsigned)snaps.front());
|
|
Line 3811: snprintf(s, sizeof(s), CLUSTER_SNAP_ITEM, name.c_str());
|
|
GitHub\ceph\src\rocksdb\db\compaction.cc (3 hits)
|
|
Line 258: snprintf(scratch->buffer + len, sizeof(scratch->buffer) - len, " + ");
|
|
Line 262: len += snprintf(scratch->buffer + len, sizeof(scratch->buffer) - len,
|
|
Line 265: snprintf(scratch->buffer + len, sizeof(scratch->buffer) - len,
|
|
GitHub\ceph\src\rocksdb\db\version_set.cc (7 hits)
|
|
Line 1446: len = snprintf(scratch->buffer, sizeof(scratch->buffer),
|
|
Line 1451: snprintf(scratch->buffer + len, sizeof(scratch->buffer) - len, " files[");
|
|
Line 1454: int ret = snprintf(scratch->buffer + len, sz, "%d ", int(files_[i].size()));
|
|
Line 1462: snprintf(scratch->buffer + len, sizeof(scratch->buffer) - len, "]");
|
|
Line 1468: int len = snprintf(scratch->buffer, sizeof(scratch->buffer), "files_size[");
|
|
Line 1473: int ret = snprintf(scratch->buffer + len, sz,
|
|
Line 1485: snprintf(scratch->buffer + len, sizeof(scratch->buffer) - len, "]");
|
|
GitHub\ceph\src\rocksdb\util\db_info_dumper.cc (2 hits)
|
|
Line 66: snprintf(str, sizeof(str), "%" PRIu64, file_size);
|
|
Line 119: snprintf(str, sizeof(str), "%" PRIu64, file_size);
|