Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/geom/part/g_part_pc98.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 2008 Marcel Moolenaar 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD: releng/8.3/sys/geom/part/g_part_pc98.c 230573 2012-01-26 09:56:29Z ae $"); 29 30 #include <sys/param.h> 31 #include <sys/bio.h> 32 #include <sys/diskpc98.h> 33 #include <sys/endian.h> 34 #include <sys/kernel.h> 35 #include <sys/kobj.h> 36 #include <sys/limits.h> 37 #include <sys/lock.h> 38 #include <sys/malloc.h> 39 #include <sys/mutex.h> 40 #include <sys/queue.h> 41 #include <sys/sbuf.h> 42 #include <sys/systm.h> 43 #include <geom/geom.h> 44 #include <geom/part/g_part.h> 45 46 #include "g_part_if.h" 47 48 #define SECSIZE 512 49 50 struct g_part_pc98_table { 51 struct g_part_table base; 52 u_char boot[SECSIZE]; 53 u_char table[SECSIZE]; 54 }; 55 56 struct g_part_pc98_entry { 57 struct g_part_entry base; 58 struct pc98_partition ent; 59 }; 60 61 static int g_part_pc98_add(struct g_part_table *, struct g_part_entry *, 62 struct g_part_parms *); 63 static int g_part_pc98_bootcode(struct g_part_table *, struct g_part_parms *); 64 static int g_part_pc98_create(struct g_part_table *, struct g_part_parms *); 65 static int g_part_pc98_destroy(struct g_part_table *, struct g_part_parms *); 66 static void g_part_pc98_dumpconf(struct g_part_table *, struct g_part_entry *, 67 struct sbuf *, const char *); 68 static int g_part_pc98_dumpto(struct g_part_table *, struct g_part_entry *); 69 static int g_part_pc98_modify(struct g_part_table *, struct g_part_entry *, 70 struct g_part_parms *); 71 static const char *g_part_pc98_name(struct g_part_table *, struct g_part_entry *, 72 char *, size_t); 73 static int g_part_pc98_probe(struct g_part_table *, struct g_consumer *); 74 static int g_part_pc98_read(struct g_part_table *, struct g_consumer *); 75 static int g_part_pc98_setunset(struct g_part_table *, struct g_part_entry *, 76 const char *, unsigned int); 77 static const char *g_part_pc98_type(struct g_part_table *, 78 struct g_part_entry *, char *, size_t); 79 static int g_part_pc98_write(struct g_part_table *, struct g_consumer *); 80 static int g_part_pc98_resize(struct g_part_table *, struct g_part_entry *, 81 struct g_part_parms *); 82 83 static kobj_method_t g_part_pc98_methods[] = { 84 KOBJMETHOD(g_part_add, g_part_pc98_add), 85 KOBJMETHOD(g_part_bootcode, g_part_pc98_bootcode), 86 KOBJMETHOD(g_part_create, g_part_pc98_create), 87 KOBJMETHOD(g_part_destroy, g_part_pc98_destroy), 88 KOBJMETHOD(g_part_dumpconf, g_part_pc98_dumpconf), 89 KOBJMETHOD(g_part_dumpto, g_part_pc98_dumpto), 90 KOBJMETHOD(g_part_modify, g_part_pc98_modify), 91 KOBJMETHOD(g_part_resize, g_part_pc98_resize), 92 KOBJMETHOD(g_part_name, g_part_pc98_name), 93 KOBJMETHOD(g_part_probe, g_part_pc98_probe), 94 KOBJMETHOD(g_part_read, g_part_pc98_read), 95 KOBJMETHOD(g_part_setunset, g_part_pc98_setunset), 96 KOBJMETHOD(g_part_type, g_part_pc98_type), 97 KOBJMETHOD(g_part_write, g_part_pc98_write), 98 { 0, 0 } 99 }; 100 101 static struct g_part_scheme g_part_pc98_scheme = { 102 "PC98", 103 g_part_pc98_methods, 104 sizeof(struct g_part_pc98_table), 105 .gps_entrysz = sizeof(struct g_part_pc98_entry), 106 .gps_minent = NDOSPART, 107 .gps_maxent = NDOSPART, 108 .gps_bootcodesz = SECSIZE, 109 }; 110 G_PART_SCHEME_DECLARE(g_part_pc98); 111 112 static int 113 pc98_parse_type(const char *type, u_char *dp_mid, u_char *dp_sid) 114 { 115 const char *alias; 116 char *endp; 117 long lt; 118 119 if (type[0] == '!') { 120 lt = strtol(type + 1, &endp, 0); 121 if (type[1] == '\0' || *endp != '\0' || lt <= 0 || 122 lt >= 65536) 123 return (EINVAL); 124 /* Make sure the active and bootable flags aren't set. */ 125 if (lt & ((PC98_SID_ACTIVE << 8) | PC98_MID_BOOTABLE)) 126 return (ENOATTR); 127 *dp_mid = (*dp_mid & PC98_MID_BOOTABLE) | (u_char)lt; 128 *dp_sid = (*dp_sid & PC98_SID_ACTIVE) | (u_char)(lt >> 8); 129 return (0); 130 } 131 alias = g_part_alias_name(G_PART_ALIAS_FREEBSD); 132 if (!strcasecmp(type, alias)) { 133 *dp_mid = (*dp_mid & PC98_MID_BOOTABLE) | PC98_MID_386BSD; 134 *dp_sid = (*dp_sid & PC98_SID_ACTIVE) | PC98_SID_386BSD; 135 return (0); 136 } 137 return (EINVAL); 138 } 139 140 static void 141 pc98_set_chs(struct g_part_table *table, uint32_t lba, u_short *cylp, 142 u_char *hdp, u_char *secp) 143 { 144 uint32_t cyl, hd, sec; 145 146 sec = lba % table->gpt_sectors + 1; 147 lba /= table->gpt_sectors; 148 hd = lba % table->gpt_heads; 149 lba /= table->gpt_heads; 150 cyl = lba; 151 152 *cylp = htole16(cyl); 153 *hdp = hd; 154 *secp = sec; 155 } 156 157 static int 158 g_part_pc98_add(struct g_part_table *basetable, struct g_part_entry *baseentry, 159 struct g_part_parms *gpp) 160 { 161 struct g_part_pc98_entry *entry; 162 struct g_part_pc98_table *table; 163 uint32_t cyl, start, size; 164 165 if (gpp->gpp_parms & G_PART_PARM_LABEL) 166 return (EINVAL); 167 168 cyl = basetable->gpt_heads * basetable->gpt_sectors; 169 170 entry = (struct g_part_pc98_entry *)baseentry; 171 table = (struct g_part_pc98_table *)basetable; 172 173 start = gpp->gpp_start; 174 size = gpp->gpp_size; 175 if (size < cyl) 176 return (EINVAL); 177 if (start % cyl) { 178 size = size - cyl + (start % cyl); 179 start = start - (start % cyl) + cyl; 180 } 181 if (size % cyl) 182 size = size - (size % cyl); 183 if (size < cyl) 184 return (EINVAL); 185 186 if (baseentry->gpe_deleted) 187 bzero(&entry->ent, sizeof(entry->ent)); 188 else 189 entry->ent.dp_mid = entry->ent.dp_sid = 0; 190 191 KASSERT(baseentry->gpe_start <= start, (__func__)); 192 KASSERT(baseentry->gpe_end >= start + size - 1, (__func__)); 193 baseentry->gpe_start = start; 194 baseentry->gpe_end = start + size - 1; 195 pc98_set_chs(basetable, baseentry->gpe_start, &entry->ent.dp_scyl, 196 &entry->ent.dp_shd, &entry->ent.dp_ssect); 197 pc98_set_chs(basetable, baseentry->gpe_end, &entry->ent.dp_ecyl, 198 &entry->ent.dp_ehd, &entry->ent.dp_esect); 199 return (pc98_parse_type(gpp->gpp_type, &entry->ent.dp_mid, 200 &entry->ent.dp_sid)); 201 } 202 203 static int 204 g_part_pc98_bootcode(struct g_part_table *basetable, struct g_part_parms *gpp) 205 { 206 struct g_part_pc98_table *table; 207 size_t codesz; 208 209 codesz = DOSMAGICOFFSET; 210 table = (struct g_part_pc98_table *)basetable; 211 bzero(table->boot, codesz); 212 codesz = MIN(codesz, gpp->gpp_codesize); 213 if (codesz > 0) 214 bcopy(gpp->gpp_codeptr, table->boot, codesz); 215 return (0); 216 } 217 218 static int 219 g_part_pc98_create(struct g_part_table *basetable, struct g_part_parms *gpp) 220 { 221 struct g_provider *pp; 222 struct g_part_pc98_table *table; 223 224 pp = gpp->gpp_provider; 225 if (pp->sectorsize < SECSIZE || pp->mediasize < 2 * SECSIZE) 226 return (ENOSPC); 227 if (pp->sectorsize > SECSIZE) 228 return (ENXIO); 229 230 basetable->gpt_first = basetable->gpt_heads * basetable->gpt_sectors; 231 basetable->gpt_last = MIN(pp->mediasize / SECSIZE, UINT32_MAX) - 1; 232 233 table = (struct g_part_pc98_table *)basetable; 234 le16enc(table->boot + DOSMAGICOFFSET, DOSMAGIC); 235 return (0); 236 } 237 238 static int 239 g_part_pc98_destroy(struct g_part_table *basetable, struct g_part_parms *gpp) 240 { 241 242 /* Wipe the first two sectors to clear the partitioning. */ 243 basetable->gpt_smhead |= 3; 244 return (0); 245 } 246 247 static void 248 g_part_pc98_dumpconf(struct g_part_table *table, 249 struct g_part_entry *baseentry, struct sbuf *sb, const char *indent) 250 { 251 struct g_part_pc98_entry *entry; 252 char name[sizeof(entry->ent.dp_name) + 1]; 253 u_int type; 254 255 entry = (struct g_part_pc98_entry *)baseentry; 256 if (entry == NULL) { 257 /* confxml: scheme information */ 258 return; 259 } 260 261 type = entry->ent.dp_mid + (entry->ent.dp_sid << 8); 262 strncpy(name, entry->ent.dp_name, sizeof(name) - 1); 263 name[sizeof(name) - 1] = '\0'; 264 if (indent == NULL) { 265 /* conftxt: libdisk compatibility */ 266 sbuf_printf(sb, " xs PC98 xt %u sn %s", type, name); 267 } else { 268 /* confxml: partition entry information */ 269 sbuf_printf(sb, "%s<label>%s</label>\n", indent, name); 270 if (entry->ent.dp_mid & PC98_MID_BOOTABLE) 271 sbuf_printf(sb, "%s<attrib>bootable</attrib>\n", 272 indent); 273 if (entry->ent.dp_sid & PC98_SID_ACTIVE) 274 sbuf_printf(sb, "%s<attrib>active</attrib>\n", indent); 275 sbuf_printf(sb, "%s<rawtype>%u</rawtype>\n", indent, 276 type & 0x7f7f); 277 } 278 } 279 280 static int 281 g_part_pc98_dumpto(struct g_part_table *table, struct g_part_entry *baseentry) 282 { 283 struct g_part_pc98_entry *entry; 284 285 /* Allow dumping to a FreeBSD partition only. */ 286 entry = (struct g_part_pc98_entry *)baseentry; 287 return (((entry->ent.dp_mid & PC98_MID_MASK) == PC98_MID_386BSD && 288 (entry->ent.dp_sid & PC98_SID_MASK) == PC98_SID_386BSD) ? 1 : 0); 289 } 290 291 static int 292 g_part_pc98_modify(struct g_part_table *basetable, 293 struct g_part_entry *baseentry, struct g_part_parms *gpp) 294 { 295 struct g_part_pc98_entry *entry; 296 297 if (gpp->gpp_parms & G_PART_PARM_LABEL) 298 return (EINVAL); 299 300 entry = (struct g_part_pc98_entry *)baseentry; 301 if (gpp->gpp_parms & G_PART_PARM_TYPE) 302 return (pc98_parse_type(gpp->gpp_type, &entry->ent.dp_mid, 303 &entry->ent.dp_sid)); 304 return (0); 305 } 306 307 static int 308 g_part_pc98_resize(struct g_part_table *basetable, 309 struct g_part_entry *baseentry, struct g_part_parms *gpp) 310 { 311 struct g_part_pc98_entry *entry; 312 uint32_t size, cyl; 313 314 cyl = basetable->gpt_heads * basetable->gpt_sectors; 315 size = gpp->gpp_size; 316 317 if (size < cyl) 318 return (EINVAL); 319 if (size % cyl) 320 size = size - (size % cyl); 321 if (size < cyl) 322 return (EINVAL); 323 324 entry = (struct g_part_pc98_entry *)baseentry; 325 baseentry->gpe_end = baseentry->gpe_start + size - 1; 326 pc98_set_chs(basetable, baseentry->gpe_end, &entry->ent.dp_ecyl, 327 &entry->ent.dp_ehd, &entry->ent.dp_esect); 328 329 return (0); 330 } 331 332 static const char * 333 g_part_pc98_name(struct g_part_table *table, struct g_part_entry *baseentry, 334 char *buf, size_t bufsz) 335 { 336 337 snprintf(buf, bufsz, "s%d", baseentry->gpe_index); 338 return (buf); 339 } 340 341 static int 342 g_part_pc98_probe(struct g_part_table *table, struct g_consumer *cp) 343 { 344 struct g_provider *pp; 345 u_char *buf, *p; 346 int error, index, res, sum; 347 uint16_t magic, ecyl, scyl; 348 349 pp = cp->provider; 350 351 /* Sanity-check the provider. */ 352 if (pp->sectorsize < SECSIZE || pp->mediasize < 2 * SECSIZE) 353 return (ENOSPC); 354 if (pp->sectorsize > SECSIZE) 355 return (ENXIO); 356 357 /* Check that there's a PC98 partition table. */ 358 buf = g_read_data(cp, 0L, 2 * SECSIZE, &error); 359 if (buf == NULL) 360 return (error); 361 362 /* We goto out on mismatch. */ 363 res = ENXIO; 364 365 magic = le16dec(buf + DOSMAGICOFFSET); 366 if (magic != DOSMAGIC) 367 goto out; 368 369 sum = 0; 370 for (index = SECSIZE; index < 2 * SECSIZE; index++) 371 sum += buf[index]; 372 if (sum == 0) { 373 res = G_PART_PROBE_PRI_LOW; 374 goto out; 375 } 376 377 for (index = 0; index < NDOSPART; index++) { 378 p = buf + SECSIZE + index * DOSPARTSIZE; 379 if (p[0] == 0 || p[1] == 0) /* !dp_mid || !dp_sid */ 380 continue; 381 scyl = le16dec(p + 10); 382 ecyl = le16dec(p + 14); 383 if (scyl == 0 || ecyl == 0) 384 goto out; 385 if (p[8] == p[12] && /* dp_ssect == dp_esect */ 386 p[9] == p[13] && /* dp_shd == dp_ehd */ 387 scyl == ecyl) 388 goto out; 389 } 390 391 res = G_PART_PROBE_PRI_HIGH; 392 393 out: 394 g_free(buf); 395 return (res); 396 } 397 398 static int 399 g_part_pc98_read(struct g_part_table *basetable, struct g_consumer *cp) 400 { 401 struct pc98_partition ent; 402 struct g_provider *pp; 403 struct g_part_pc98_table *table; 404 struct g_part_pc98_entry *entry; 405 u_char *buf, *p; 406 off_t msize; 407 off_t start, end; 408 u_int cyl; 409 int error, index; 410 411 pp = cp->provider; 412 table = (struct g_part_pc98_table *)basetable; 413 msize = MIN(pp->mediasize / SECSIZE, UINT32_MAX); 414 415 buf = g_read_data(cp, 0L, 2 * SECSIZE, &error); 416 if (buf == NULL) 417 return (error); 418 419 cyl = basetable->gpt_heads * basetable->gpt_sectors; 420 421 bcopy(buf, table->boot, sizeof(table->boot)); 422 bcopy(buf + SECSIZE, table->table, sizeof(table->table)); 423 424 for (index = NDOSPART - 1; index >= 0; index--) { 425 p = buf + SECSIZE + index * DOSPARTSIZE; 426 ent.dp_mid = p[0]; 427 ent.dp_sid = p[1]; 428 ent.dp_dum1 = p[2]; 429 ent.dp_dum2 = p[3]; 430 ent.dp_ipl_sct = p[4]; 431 ent.dp_ipl_head = p[5]; 432 ent.dp_ipl_cyl = le16dec(p + 6); 433 ent.dp_ssect = p[8]; 434 ent.dp_shd = p[9]; 435 ent.dp_scyl = le16dec(p + 10); 436 ent.dp_esect = p[12]; 437 ent.dp_ehd = p[13]; 438 ent.dp_ecyl = le16dec(p + 14); 439 bcopy(p + 16, ent.dp_name, sizeof(ent.dp_name)); 440 if (ent.dp_sid == 0) 441 continue; 442 443 start = ent.dp_scyl * cyl; 444 end = (ent.dp_ecyl + 1) * cyl - 1; 445 entry = (struct g_part_pc98_entry *)g_part_new_entry(basetable, 446 index + 1, start, end); 447 entry->ent = ent; 448 } 449 450 basetable->gpt_entries = NDOSPART; 451 basetable->gpt_first = cyl; 452 basetable->gpt_last = msize - 1; 453 454 g_free(buf); 455 return (0); 456 } 457 458 static int 459 g_part_pc98_setunset(struct g_part_table *table, struct g_part_entry *baseentry, 460 const char *attrib, unsigned int set) 461 { 462 struct g_part_entry *iter; 463 struct g_part_pc98_entry *entry; 464 int changed, mid, sid; 465 466 mid = sid = 0; 467 if (strcasecmp(attrib, "active") == 0) 468 sid = 1; 469 else if (strcasecmp(attrib, "bootable") == 0) 470 mid = 1; 471 if (mid == 0 && sid == 0) 472 return (EINVAL); 473 474 LIST_FOREACH(iter, &table->gpt_entry, gpe_entry) { 475 if (iter->gpe_deleted) 476 continue; 477 if (iter != baseentry) 478 continue; 479 changed = 0; 480 entry = (struct g_part_pc98_entry *)iter; 481 if (set) { 482 if (mid && !(entry->ent.dp_mid & PC98_MID_BOOTABLE)) { 483 entry->ent.dp_mid |= PC98_MID_BOOTABLE; 484 changed = 1; 485 } 486 if (sid && !(entry->ent.dp_sid & PC98_SID_ACTIVE)) { 487 entry->ent.dp_sid |= PC98_SID_ACTIVE; 488 changed = 1; 489 } 490 } else { 491 if (mid && (entry->ent.dp_mid & PC98_MID_BOOTABLE)) { 492 entry->ent.dp_mid &= ~PC98_MID_BOOTABLE; 493 changed = 1; 494 } 495 if (sid && (entry->ent.dp_sid & PC98_SID_ACTIVE)) { 496 entry->ent.dp_sid &= ~PC98_SID_ACTIVE; 497 changed = 1; 498 } 499 } 500 if (changed && !iter->gpe_created) 501 iter->gpe_modified = 1; 502 } 503 return (0); 504 } 505 506 static const char * 507 g_part_pc98_type(struct g_part_table *basetable, struct g_part_entry *baseentry, 508 char *buf, size_t bufsz) 509 { 510 struct g_part_pc98_entry *entry; 511 u_int type; 512 513 entry = (struct g_part_pc98_entry *)baseentry; 514 type = (entry->ent.dp_mid & PC98_MID_MASK) | 515 ((entry->ent.dp_sid & PC98_SID_MASK) << 8); 516 if (type == (PC98_MID_386BSD | (PC98_SID_386BSD << 8))) 517 return (g_part_alias_name(G_PART_ALIAS_FREEBSD)); 518 snprintf(buf, bufsz, "!%d", type); 519 return (buf); 520 } 521 522 static int 523 g_part_pc98_write(struct g_part_table *basetable, struct g_consumer *cp) 524 { 525 struct g_part_entry *baseentry; 526 struct g_part_pc98_entry *entry; 527 struct g_part_pc98_table *table; 528 u_char *p; 529 int error, index; 530 531 table = (struct g_part_pc98_table *)basetable; 532 baseentry = LIST_FIRST(&basetable->gpt_entry); 533 for (index = 1; index <= basetable->gpt_entries; index++) { 534 p = table->table + (index - 1) * DOSPARTSIZE; 535 entry = (baseentry != NULL && index == baseentry->gpe_index) 536 ? (struct g_part_pc98_entry *)baseentry : NULL; 537 if (entry != NULL && !baseentry->gpe_deleted) { 538 p[0] = entry->ent.dp_mid; 539 p[1] = entry->ent.dp_sid; 540 p[2] = entry->ent.dp_dum1; 541 p[3] = entry->ent.dp_dum2; 542 p[4] = entry->ent.dp_ipl_sct; 543 p[5] = entry->ent.dp_ipl_head; 544 le16enc(p + 6, entry->ent.dp_ipl_cyl); 545 p[8] = entry->ent.dp_ssect; 546 p[9] = entry->ent.dp_shd; 547 le16enc(p + 10, entry->ent.dp_scyl); 548 p[12] = entry->ent.dp_esect; 549 p[13] = entry->ent.dp_ehd; 550 le16enc(p + 14, entry->ent.dp_ecyl); 551 bcopy(entry->ent.dp_name, p + 16, 552 sizeof(entry->ent.dp_name)); 553 } else 554 bzero(p, DOSPARTSIZE); 555 556 if (entry != NULL) 557 baseentry = LIST_NEXT(baseentry, gpe_entry); 558 } 559 560 error = g_write_data(cp, 0, table->boot, SECSIZE); 561 if (!error) 562 error = g_write_data(cp, SECSIZE, table->table, SECSIZE); 563 return (error); 564 }
Cache object: 8189328b791e7f0278bad66a0f32cbfc
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]