str 23 arch/x86/boot/mkcpustr.c const char *str;
str 29 arch/x86/boot/mkcpustr.c str = x86_cap_flags[i*32+j];
str 35 arch/x86/boot/mkcpustr.c if (!str)
str 36 arch/x86/boot/mkcpustr.c str = "";
str 38 arch/x86/boot/mkcpustr.c i, j, str);
str 39 arch/x86/boot/mkcpustr.c } else if (str) {
str 43 arch/x86/boot/mkcpustr.c i, j, i, j, str);
str 92 arch/x86/boot/printf.c *str++ = ' ';
str 94 arch/x86/boot/printf.c *str++ = sign;
str 97 arch/x86/boot/printf.c *str++ = '0';
str 99 arch/x86/boot/printf.c *str++ = '0';
str 100 arch/x86/boot/printf.c *str++ = ('X' | locase);
str 105 arch/x86/boot/printf.c *str++ = c;
str 107 arch/x86/boot/printf.c *str++ = '0';
str 109 arch/x86/boot/printf.c *str++ = tmp[i];
str 111 arch/x86/boot/printf.c *str++ = ' ';
str 112 arch/x86/boot/printf.c return str;
str 120 arch/x86/boot/printf.c char *str;
str 130 arch/x86/boot/printf.c for (str = buf; *fmt; ++fmt) {
str 132 arch/x86/boot/printf.c *str++ = *fmt;
str 201 arch/x86/boot/printf.c *str++ = ' ';
str 202 arch/x86/boot/printf.c *str++ = (unsigned char)va_arg(args, int);
str 204 arch/x86/boot/printf.c *str++ = ' ';
str 213 arch/x86/boot/printf.c *str++ = ' ';
str 215 arch/x86/boot/printf.c *str++ = *s++;
str 217 arch/x86/boot/printf.c *str++ = ' ';
str 225 arch/x86/boot/printf.c str = number(str,
str 233 arch/x86/boot/printf.c *ip = (str - buf);
str 236 arch/x86/boot/printf.c *ip = (str - buf);
str 241 arch/x86/boot/printf.c *str++ = '%';
str 262 arch/x86/boot/printf.c *str++ = '%';
str 264 arch/x86/boot/printf.c *str++ = *fmt;
str 279 arch/x86/boot/printf.c str = number(str, num, base, field_width, precision, flags);
str 281 arch/x86/boot/printf.c *str = '\0';
str 282 arch/x86/boot/printf.c return str - buf;
str 125 arch/x86/boot/tools/build.c va_start(args, str);
str 126 arch/x86/boot/tools/build.c vfprintf(stderr, str, args);
str 39 arch/x86/boot/tty.c while (*str) {
str 40 arch/x86/boot/tty.c putchar(*str++);
str 146 arch/x86/kernel/acpi/sleep.c while ((str != NULL) && (*str != '\0')) {
str 147 arch/x86/kernel/acpi/sleep.c if (strncmp(str, "s3_bios", 7) == 0)
str 149 arch/x86/kernel/acpi/sleep.c if (strncmp(str, "s3_mode", 7) == 0)
str 151 arch/x86/kernel/acpi/sleep.c if (strncmp(str, "s3_beep", 7) == 0)
str 154 arch/x86/kernel/acpi/sleep.c if (strncmp(str, "s4_nohwsig", 10) == 0)
str 157 arch/x86/kernel/acpi/sleep.c if (strncmp(str, "old_ordering", 12) == 0)
str 159 arch/x86/kernel/acpi/sleep.c str = strchr(str, ',');
str 160 arch/x86/kernel/acpi/sleep.c if (str != NULL)
str 161 arch/x86/kernel/acpi/sleep.c str += strspn(str, ", \t");
str 1213 arch/x86/kernel/amd_iommu_init.c for (; *str; ++str) {
str 1214 arch/x86/kernel/amd_iommu_init.c if (strncmp(str, "isolate", 7) == 0)
str 1216 arch/x86/kernel/amd_iommu_init.c if (strncmp(str, "fullflush", 11) == 0)
str 1225 arch/x86/kernel/amd_iommu_init.c unsigned order = PAGE_SHIFT + get_order(memparse(str, &str));
str 484 arch/x86/kernel/apm_32.c printk(KERN_NOTICE "apm: %s: %s\n", str, error_table[i].msg);
str 487 arch/x86/kernel/apm_32.c str, err);
str 1821 arch/x86/kernel/apm_32.c while ((str != NULL) && (*str != '\0')) {
str 1822 arch/x86/kernel/apm_32.c if (strncmp(str, "off", 3) == 0)
str 1824 arch/x86/kernel/apm_32.c if (strncmp(str, "on", 2) == 0)
str 1826 arch/x86/kernel/apm_32.c if ((strncmp(str, "bounce-interval=", 16) == 0) ||
str 1827 arch/x86/kernel/apm_32.c (strncmp(str, "bounce_interval=", 16) == 0))
str 1828 arch/x86/kernel/apm_32.c bounce_interval = simple_strtol(str + 16, NULL, 0);
str 1829 arch/x86/kernel/apm_32.c if ((strncmp(str, "idle-threshold=", 15) == 0) ||
str 1830 arch/x86/kernel/apm_32.c (strncmp(str, "idle_threshold=", 15) == 0))
str 1831 arch/x86/kernel/apm_32.c idle_threshold = simple_strtol(str + 15, NULL, 0);
str 1832 arch/x86/kernel/apm_32.c if ((strncmp(str, "idle-period=", 12) == 0) ||
str 1833 arch/x86/kernel/apm_32.c (strncmp(str, "idle_period=", 12) == 0))
str 1834 arch/x86/kernel/apm_32.c idle_period = simple_strtol(str + 12, NULL, 0);
str 1835 arch/x86/kernel/apm_32.c invert = (strncmp(str, "no-", 3) == 0) ||
str 1836 arch/x86/kernel/apm_32.c (strncmp(str, "no_", 3) == 0);
str 1838 arch/x86/kernel/apm_32.c str += 3;
str 1839 arch/x86/kernel/apm_32.c if (strncmp(str, "debug", 5) == 0)
str 1841 arch/x86/kernel/apm_32.c if ((strncmp(str, "power-off", 9) == 0) ||
str 1842 arch/x86/kernel/apm_32.c (strncmp(str, "power_off", 9) == 0))
str 1844 arch/x86/kernel/apm_32.c if (strncmp(str, "smp", 3) == 0) {
str 1848 arch/x86/kernel/apm_32.c if ((strncmp(str, "allow-ints", 10) == 0) ||
str 1849 arch/x86/kernel/apm_32.c (strncmp(str, "allow_ints", 10) == 0))
str 1851 arch/x86/kernel/apm_32.c if ((strncmp(str, "broken-psr", 10) == 0) ||
str 1852 arch/x86/kernel/apm_32.c (strncmp(str, "broken_psr", 10) == 0))
str 1854 arch/x86/kernel/apm_32.c if ((strncmp(str, "realmode-power-off", 18) == 0) ||
str 1855 arch/x86/kernel/apm_32.c (strncmp(str, "realmode_power_off", 18) == 0))
str 1857 arch/x86/kernel/apm_32.c str = strchr(str, ',');
str 1858 arch/x86/kernel/apm_32.c if (str != NULL)
str 1859 arch/x86/kernel/apm_32.c str += strspn(str, ", \t");
str 26 arch/x86/kernel/bios_uv.c const char *str;
str 28 arch/x86/kernel/bios_uv.c case 0: str = "Call completed without error"; break;
str 29 arch/x86/kernel/bios_uv.c case -1: str = "Not implemented"; break;
str 30 arch/x86/kernel/bios_uv.c case -2: str = "Invalid argument"; break;
str 31 arch/x86/kernel/bios_uv.c case -3: str = "Call completed with error"; break;
str 32 arch/x86/kernel/bios_uv.c default: str = "Unknown BIOS status code"; break;
str 34 arch/x86/kernel/bios_uv.c return str;
str 102 arch/x86/kernel/cpu/common.c get_option(&str, &cachesize_override);
str 255 arch/x86/kernel/cpu/cpufreq/elanfreq.c max_freq = simple_strtoul(str, &str, 0);
str 716 arch/x86/kernel/cpu/mcheck/mce_64.c if (!strcmp(str, "off"))
str 718 arch/x86/kernel/cpu/mcheck/mce_64.c else if (!strcmp(str, "bootlog") || !strcmp(str,"nobootlog"))
str 719 arch/x86/kernel/cpu/mcheck/mce_64.c mce_bootlog = str[0] == 'b';
str 720 arch/x86/kernel/cpu/mcheck/mce_64.c else if (isdigit(str[0]))
str 721 arch/x86/kernel/cpu/mcheck/mce_64.c get_option(&str, &tolerant);
str 723 arch/x86/kernel/cpu/mcheck/mce_64.c printk("mce= argument %s ignored. Please use /sys", str);
str 335 arch/x86/kernel/dumpstack_32.c printk(KERN_EMERG "%s: %04lx [#%d] ", str, err & 0xffff, ++die_counter);
str 346 arch/x86/kernel/dumpstack_32.c if (notify_die(DIE_OOPS, str, regs, err,
str 375 arch/x86/kernel/dumpstack_32.c if (__die(str, regs, err))
str 389 arch/x86/kernel/dumpstack_32.c if (notify_die(DIE_NMIWATCHDOG, str, regs, 0, 2, SIGINT) == NOTIFY_STOP)
str 398 arch/x86/kernel/dumpstack_32.c printk(KERN_EMERG "%s", str);
str 481 arch/x86/kernel/dumpstack_64.c printk(KERN_EMERG "%s: %04lx [#%d] ", str, err & 0xffff, ++die_counter);
str 492 arch/x86/kernel/dumpstack_64.c if (notify_die(DIE_OOPS, str, regs, err,
str 514 arch/x86/kernel/dumpstack_64.c if (__die(str, regs, err))
str 524 arch/x86/kernel/dumpstack_64.c if (notify_die(DIE_NMIWATCHDOG, str, regs, 0, 2, SIGINT) == NOTIFY_STOP)
str 532 arch/x86/kernel/dumpstack_64.c printk(KERN_EMERG "%s", str);
str 31 arch/x86/kernel/early_printk.c while ((c = *str++) != '\0' && n-- > 0) {
str 864 arch/x86/kernel/early_printk.c dbgp_endpoint_out, str, chunk);
str 865 arch/x86/kernel/early_printk.c str += chunk;
str 903 arch/x86/kernel/early_printk.c if (*str == '=')
str 904 arch/x86/kernel/early_printk.c fn = ++str;
str 64 arch/x86/kernel/hpet.c if (str) {
str 65 arch/x86/kernel/hpet.c if (!strncmp("disable", str, 7))
str 67 arch/x86/kernel/hpet.c if (!strncmp("force", str, 5))
str 782 arch/x86/kernel/io_apic_32.c get_options(str, ARRAY_SIZE(ints), ints);
str 269 arch/x86/kernel/mfgpt_32.c get_option(&str, &irq);
str 79 arch/x86/kernel/mpparse.c char str[7];
str 80 arch/x86/kernel/mpparse.c memcpy(str, m->mpc_bustype, 6);
str 81 arch/x86/kernel/mpparse.c str[6] = 0;
str 84 arch/x86/kernel/mpparse.c x86_quirks->mpc_oem_bus_info(m, str);
str 86 arch/x86/kernel/mpparse.c apic_printk(APIC_VERBOSE, "Bus #%d is %s\n", m->mpc_busid, str);
str 92 arch/x86/kernel/mpparse.c m->mpc_busid, str, MAX_MP_BUSSES - 1);
str 97 arch/x86/kernel/mpparse.c if (strncmp(str, BUSTYPE_ISA, sizeof(BUSTYPE_ISA) - 1) == 0) {
str 102 arch/x86/kernel/mpparse.c } else if (strncmp(str, BUSTYPE_PCI, sizeof(BUSTYPE_PCI) - 1) == 0) {
str 109 arch/x86/kernel/mpparse.c } else if (strncmp(str, BUSTYPE_EISA, sizeof(BUSTYPE_EISA) - 1) == 0) {
str 111 arch/x86/kernel/mpparse.c } else if (strncmp(str, BUSTYPE_MCA, sizeof(BUSTYPE_MCA) - 1) == 0) {
str 115 arch/x86/kernel/mpparse.c printk(KERN_WARNING "Unknown bustype %s - ignoring\n", str);
str 276 arch/x86/kernel/mpparse.c memcpy(str, mpc->mpc_productid, 12);
str 277 arch/x86/kernel/mpparse.c str[12] = 0;
str 279 arch/x86/kernel/mpparse.c printk(KERN_INFO "MPTABLE: Product ID: %s\n", str);
str 288 arch/x86/kernel/mpparse.c char str[16];
str 294 arch/x86/kernel/mpparse.c if (!smp_check_mpc(mpc, oem, str))
str 304 arch/x86/kernel/mpparse.c numaq_mps_oem_check(mpc, oem, str);
str 307 arch/x86/kernel/mpparse.c mps_oem_check(mpc, oem, str);
str 1014 arch/x86/kernel/mpparse.c char str[16];
str 1038 arch/x86/kernel/mpparse.c if (!smp_check_mpc(mpc, oem, str))
str 194 arch/x86/kernel/nmi.c if (!strncmp(str, "panic", 5)) {
str 196 arch/x86/kernel/nmi.c str = strchr(str, ',');
str 197 arch/x86/kernel/nmi.c if (!str)
str 199 arch/x86/kernel/nmi.c ++str;
str 202 arch/x86/kernel/nmi.c get_option(&str, &nmi);
str 40 arch/x86/kernel/olpc.c if (get_option(&str, &ec_timeout) != 1) {
str 338 arch/x86/kernel/process.c if (!str)
str 341 arch/x86/kernel/process.c if (!strcmp(str, "poll")) {
str 344 arch/x86/kernel/process.c } else if (!strcmp(str, "mwait"))
str 346 arch/x86/kernel/process.c else if (!strcmp(str, "halt")) {
str 357 arch/x86/kernel/process.c } else if (!strcmp(str, "nomwait")) {
str 57 arch/x86/kernel/reboot.c switch (*str) {
str 69 arch/x86/kernel/reboot.c if (isdigit(*(str+1))) {
str 70 arch/x86/kernel/reboot.c reboot_cpu = (int) (*(str+1) - '0');
str 71 arch/x86/kernel/reboot.c if (isdigit(*(str+2)))
str 72 arch/x86/kernel/reboot.c reboot_cpu = reboot_cpu*10 + (int)(*(str+2) - '0');
str 86 arch/x86/kernel/reboot.c reboot_type = *str;
str 94 arch/x86/kernel/reboot.c str = strchr(str, ',');
str 95 arch/x86/kernel/reboot.c if (str)
str 96 arch/x86/kernel/reboot.c str++;
str 119 arch/x86/kernel/traps.c die(str, regs, err);
str 205 arch/x86/kernel/traps.c tsk->comm, tsk->pid, str,
str 222 arch/x86/kernel/traps.c die(str, regs, error_code);
str 238 arch/x86/kernel/traps.c if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
str 242 arch/x86/kernel/traps.c do_trap(trapnr, signr, str, regs, error_code, NULL); \
str 253 arch/x86/kernel/traps.c if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
str 257 arch/x86/kernel/traps.c do_trap(trapnr, signr, str, regs, error_code, &info); \
str 286 arch/x86/kernel/traps.c static const char str[] = "double fault";
str 290 arch/x86/kernel/traps.c notify_die(DIE_TRAP, str, regs, error_code, 8, SIGSEGV);
str 298 arch/x86/kernel/traps.c die(str, regs, error_code);
str 650 arch/x86/kernel/traps.c notify_die(DIE_GPF, str, regs, 0, trapnr, SIGFPE);
str 653 arch/x86/kernel/traps.c die(str, regs, 0);
str 147 arch/x86/mach-default/setup.c get_option(&str, &no_broadcast);
str 578 arch/x86/mm/init_32.c if (!str || !strcmp(str, "on")) {
str 584 arch/x86/mm/init_32.c if (!strcmp(str, "off")) {
str 106 arch/x86/mm/init_64.c if (!str)
str 108 arch/x86/mm/init_64.c if (!strncmp(str, "on", 2)) {
str 111 arch/x86/mm/init_64.c } else if (!strncmp(str, "off", 3)) {
str 140 arch/x86/mm/init_64.c if (!strcmp(str, "on"))
str 142 arch/x86/mm/init_64.c else if (!strcmp(str, "off"))
str 436 arch/x86/pci/common.c if (!strcmp(str, "off")) {
str 439 arch/x86/pci/common.c } else if (!strcmp(str, "bfsort")) {
str 442 arch/x86/pci/common.c } else if (!strcmp(str, "nobfsort")) {
str 447 arch/x86/pci/common.c else if (!strcmp(str, "bios")) {
str 450 arch/x86/pci/common.c } else if (!strcmp(str, "nobios")) {
str 453 arch/x86/pci/common.c } else if (!strcmp(str, "biosirq")) {
str 456 arch/x86/pci/common.c } else if (!strncmp(str, "pirqaddr=", 9)) {
str 457 arch/x86/pci/common.c pirq_table_addr = simple_strtoul(str+9, NULL, 0);
str 462 arch/x86/pci/common.c else if (!strcmp(str, "conf1")) {
str 466 arch/x86/pci/common.c else if (!strcmp(str, "conf2")) {
str 472 arch/x86/pci/common.c else if (!strcmp(str, "nommconf")) {
str 476 arch/x86/pci/common.c else if (!strcmp(str, "check_enable_amd_mmconf")) {
str 481 arch/x86/pci/common.c else if (!strcmp(str, "noacpi")) {
str 485 arch/x86/pci/common.c else if (!strcmp(str, "noearly")) {
str 490 arch/x86/pci/common.c else if (!strcmp(str, "usepirqmask")) {
str 493 arch/x86/pci/common.c } else if (!strncmp(str, "irqmask=", 8)) {
str 494 arch/x86/pci/common.c pcibios_irq_mask = simple_strtol(str+8, NULL, 0);
str 496 arch/x86/pci/common.c } else if (!strncmp(str, "lastbus=", 8)) {
str 497 arch/x86/pci/common.c pcibios_last_bus = simple_strtol(str+8, NULL, 0);
str 501 arch/x86/pci/common.c else if (!strcmp(str, "rom")) {
str 504 arch/x86/pci/common.c } else if (!strcmp(str, "norom")) {
str 507 arch/x86/pci/common.c } else if (!strcmp(str, "assign-busses")) {
str 510 arch/x86/pci/common.c } else if (!strcmp(str, "use_crs")) {
str 513 arch/x86/pci/common.c } else if (!strcmp(str, "earlydump")) {
str 516 arch/x86/pci/common.c } else if (!strcmp(str, "routeirq")) {
str 519 arch/x86/pci/common.c } else if (!strcmp(str, "skip_isa_align")) {
str 523 arch/x86/pci/common.c return str;
str 1275 block/blk-core.c return setup_fault_attr(&fail_make_request, str);
str 17 block/blk-timeout.c return setup_fault_attr(&fail_io_timeout, str);
str 194 block/elevator.c if (!strcmp(str, "as"))
str 197 block/elevator.c strncpy(chosen_elevator, str, sizeof(chosen_elevator) - 1);
str 21 crypto/fips.c fips_enabled = !!simple_strtol(str, NULL, 0);
str 85 fs/9p/vfs_dir.c over = filldir(dirent, st->name.str, st->name.len, filp->f_pos,
str 848 fs/9p/vfs_inode.c memmove(ext, stat->extension.str, n);
str 861 fs/9p/vfs_inode.c stat->extension.len, stat->extension.str);
str 932 fs/9p/vfs_inode.c memmove(buffer, st->extension.str, buflen - 1);
str 937 fs/9p/vfs_inode.c st->extension.str, buffer);
str 367 fs/autofs4/root.c const unsigned char *str = name->name;
str 396 fs/autofs4/root.c if (memcmp(qstr->name, str, len))
str 419 fs/autofs4/root.c const unsigned char *str = name->name;
str 448 fs/autofs4/root.c if (memcmp(qstr->name, str, len))
str 509 fs/cifs/readdir.c __le16 *ustr = (__le16 *)str;
str 308 fs/cifs/smbdes.c key[0] = str[0] >> 1;
str 309 fs/cifs/smbdes.c key[1] = ((str[0] & 0x01) << 6) | (str[1] >> 2);
str 310 fs/cifs/smbdes.c key[2] = ((str[1] & 0x03) << 5) | (str[2] >> 3);
str 311 fs/cifs/smbdes.c key[3] = ((str[2] & 0x07) << 4) | (str[3] >> 4);
str 312 fs/cifs/smbdes.c key[4] = ((str[3] & 0x0F) << 3) | (str[4] >> 5);
str 313 fs/cifs/smbdes.c key[5] = ((str[4] & 0x1F) << 2) | (str[5] >> 6);
str 314 fs/cifs/smbdes.c key[6] = ((str[5] & 0x3F) << 1) | (str[6] >> 7);
str 315 fs/cifs/smbdes.c key[7] = str[6] & 0x7F;
str 86 fs/cifs/smbencrypt.c while (*str++ != 0)
str 1262 fs/compat.c compat_uptr_t str;
str 1266 fs/compat.c if (get_user(str, argv+argc) ||
str 1267 fs/compat.c !(len = strnlen_user(compat_ptr(str), MAX_ARG_STRLEN))) {
str 1279 fs/compat.c str += len;
str 1295 fs/compat.c str -= bytes_to_copy;
str 1328 fs/compat.c if (copy_from_user(kaddr+offset, compat_ptr(str),
str 1372 fs/dcache.c const unsigned char *str = name->name;
str 1413 fs/dcache.c if (memcmp(qstr->name, str, len))
str 1885 fs/dcache.c memcpy(*buffer, str, namelen);
str 2245 fs/dcache.c if (!str)
str 2247 fs/dcache.c dhash_entries = simple_strtoul(str, &str, 0);
str 1196 fs/ecryptfs/crypto.c str[0] = '\0';
str 1199 fs/ecryptfs/crypto.c strcpy(str, ecryptfs_cipher_code_str_map[i].cipher_str);
str 1200 fs/ecryptfs/crypto.c if (str[0] == '\0') {
str 416 fs/exec.c char __user *str;
str 420 fs/exec.c if (get_user(str, argv+argc) ||
str 421 fs/exec.c !(len = strnlen_user(str, MAX_ARG_STRLEN))) {
str 433 fs/exec.c str += len;
str 449 fs/exec.c str -= bytes_to_copy;
str 471 fs/exec.c if (copy_from_user(kaddr+offset, str, bytes_to_copy)) {
str 2037 fs/ext4/mballoc.c char str[32];
str 2040 fs/ext4/mballoc.c if (count >= sizeof(str)) {
str 2042 fs/ext4/mballoc.c "mb_history", (int)sizeof(str));
str 2046 fs/ext4/mballoc.c if (copy_from_user(str, buffer, count))
str 2049 fs/ext4/mballoc.c value = simple_strtol(str, NULL, 0);
str 3582 fs/ext4/super.c char str[32];
str 3585 fs/ext4/super.c if (cnt >= sizeof(str))
str 3587 fs/ext4/super.c if (copy_from_user(str, buf, cnt))
str 3589 fs/ext4/super.c value = simple_strtol(str, NULL, 0);
str 1012 fs/gfs2/dir.c struct qstr str;
str 1013 fs/gfs2/dir.c str.name = (char*)(dent+1);
str 1014 fs/gfs2/dir.c str.len = be16_to_cpu(dent->de_name_len);
str 1015 fs/gfs2/dir.c str.hash = be32_to_cpu(dent->de_hash);
str 1016 fs/gfs2/dir.c new = gfs2_dirent_alloc(inode, nbh, &str);
str 252 fs/gfs2/inode.c const struct gfs2_dinode *str = buf;
str 256 fs/gfs2/inode.c if (unlikely(ip->i_no_addr != be64_to_cpu(str->di_num.no_addr)))
str 258 fs/gfs2/inode.c ip->i_no_formal_ino = be64_to_cpu(str->di_num.no_formal_ino);
str 259 fs/gfs2/inode.c ip->i_inode.i_mode = be32_to_cpu(str->di_mode);
str 264 fs/gfs2/inode.c ip->i_inode.i_rdev = MKDEV(be32_to_cpu(str->di_major),
str 265 fs/gfs2/inode.c be32_to_cpu(str->di_minor));
str 269 fs/gfs2/inode.c ip->i_inode.i_uid = be32_to_cpu(str->di_uid);
str 270 fs/gfs2/inode.c ip->i_inode.i_gid = be32_to_cpu(str->di_gid);
str 276 fs/gfs2/inode.c ip->i_inode.i_nlink = be32_to_cpu(str->di_nlink);
str 277 fs/gfs2/inode.c di->di_size = be64_to_cpu(str->di_size);
str 279 fs/gfs2/inode.c gfs2_set_inode_blocks(&ip->i_inode, be64_to_cpu(str->di_blocks));
str 280 fs/gfs2/inode.c atime.tv_sec = be64_to_cpu(str->di_atime);
str 281 fs/gfs2/inode.c atime.tv_nsec = be32_to_cpu(str->di_atime_nsec);
str 284 fs/gfs2/inode.c ip->i_inode.i_mtime.tv_sec = be64_to_cpu(str->di_mtime);
str 285 fs/gfs2/inode.c ip->i_inode.i_mtime.tv_nsec = be32_to_cpu(str->di_mtime_nsec);
str 286 fs/gfs2/inode.c ip->i_inode.i_ctime.tv_sec = be64_to_cpu(str->di_ctime);
str 287 fs/gfs2/inode.c ip->i_inode.i_ctime.tv_nsec = be32_to_cpu(str->di_ctime_nsec);
str 289 fs/gfs2/inode.c ip->i_goal = be64_to_cpu(str->di_goal_meta);
str 290 fs/gfs2/inode.c di->di_generation = be64_to_cpu(str->di_generation);
str 292 fs/gfs2/inode.c di->di_flags = be32_to_cpu(str->di_flags);
str 294 fs/gfs2/inode.c height = be16_to_cpu(str->di_height);
str 299 fs/gfs2/inode.c depth = be16_to_cpu(str->di_depth);
str 303 fs/gfs2/inode.c di->di_entries = be32_to_cpu(str->di_entries);
str 305 fs/gfs2/inode.c di->di_eattr = be64_to_cpu(str->di_eattr);
str 529 fs/gfs2/inode.c const struct gfs2_inum_range *str = buf;
str 531 fs/gfs2/inode.c ir->ir_start = be64_to_cpu(str->ir_start);
str 532 fs/gfs2/inode.c ir->ir_length = be64_to_cpu(str->ir_length);
str 537 fs/gfs2/inode.c struct gfs2_inum_range *str = buf;
str 539 fs/gfs2/inode.c str->ir_start = cpu_to_be64(ir->ir_start);
str 540 fs/gfs2/inode.c str->ir_length = cpu_to_be64(ir->ir_length);
str 1246 fs/gfs2/inode.c struct gfs2_dinode *str = buf;
str 1248 fs/gfs2/inode.c str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
str 1249 fs/gfs2/inode.c str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI);
str 1250 fs/gfs2/inode.c str->di_header.__pad0 = 0;
str 1251 fs/gfs2/inode.c str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI);
str 1252 fs/gfs2/inode.c str->di_header.__pad1 = 0;
str 1253 fs/gfs2/inode.c str->di_num.no_addr = cpu_to_be64(ip->i_no_addr);
str 1254 fs/gfs2/inode.c str->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino);
str 1255 fs/gfs2/inode.c str->di_mode = cpu_to_be32(ip->i_inode.i_mode);
str 1256 fs/gfs2/inode.c str->di_uid = cpu_to_be32(ip->i_inode.i_uid);
str 1257 fs/gfs2/inode.c str->di_gid = cpu_to_be32(ip->i_inode.i_gid);
str 1258 fs/gfs2/inode.c str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink);
str 1259 fs/gfs2/inode.c str->di_size = cpu_to_be64(di->di_size);
str 1260 fs/gfs2/inode.c str->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode));
str 1261 fs/gfs2/inode.c str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec);
str 1262 fs/gfs2/inode.c str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec);
str 1263 fs/gfs2/inode.c str->di_ctime = cpu_to_be64(ip->i_inode.i_ctime.tv_sec);
str 1265 fs/gfs2/inode.c str->di_goal_meta = cpu_to_be64(ip->i_goal);
str 1266 fs/gfs2/inode.c str->di_goal_data = cpu_to_be64(ip->i_goal);
str 1267 fs/gfs2/inode.c str->di_generation = cpu_to_be64(di->di_generation);
str 1269 fs/gfs2/inode.c str->di_flags = cpu_to_be32(di->di_flags);
str 1270 fs/gfs2/inode.c str->di_height = cpu_to_be16(ip->i_height);
str 1271 fs/gfs2/inode.c str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) &&
str 1274 fs/gfs2/inode.c str->di_depth = cpu_to_be16(ip->i_depth);
str 1275 fs/gfs2/inode.c str->di_entries = cpu_to_be32(di->di_entries);
str 1277 fs/gfs2/inode.c str->di_eattr = cpu_to_be64(di->di_eattr);
str 1278 fs/gfs2/inode.c str->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec);
str 1279 fs/gfs2/inode.c str->di_mtime_nsec = cpu_to_be32(ip->i_inode.i_mtime.tv_nsec);
str 1280 fs/gfs2/inode.c str->di_ctime_nsec = cpu_to_be32(ip->i_inode.i_ctime.tv_nsec);
str 376 fs/gfs2/locking/dlm/lock.c sprintf(str->name, "%8x%16llx", lockname->ln_type,
str 378 fs/gfs2/locking/dlm/lock.c str->namelen = GDLM_STRNAME_BYTES;
str 107 fs/gfs2/ops_dentry.c str->hash = gfs2_disk_hash(str->name, str->len);
str 230 fs/gfs2/ops_fstype.c const struct gfs2_sb *str = buf;
str 232 fs/gfs2/ops_fstype.c sb->sb_magic = be32_to_cpu(str->sb_header.mh_magic);
str 233 fs/gfs2/ops_fstype.c sb->sb_type = be32_to_cpu(str->sb_header.mh_type);
str 234 fs/gfs2/ops_fstype.c sb->sb_format = be32_to_cpu(str->sb_header.mh_format);
str 235 fs/gfs2/ops_fstype.c sb->sb_fs_format = be32_to_cpu(str->sb_fs_format);
str 236 fs/gfs2/ops_fstype.c sb->sb_multihost_format = be32_to_cpu(str->sb_multihost_format);
str 237 fs/gfs2/ops_fstype.c sb->sb_bsize = be32_to_cpu(str->sb_bsize);
str 238 fs/gfs2/ops_fstype.c sb->sb_bsize_shift = be32_to_cpu(str->sb_bsize_shift);
str 239 fs/gfs2/ops_fstype.c sb->sb_master_dir.no_addr = be64_to_cpu(str->sb_master_dir.no_addr);
str 240 fs/gfs2/ops_fstype.c sb->sb_master_dir.no_formal_ino = be64_to_cpu(str->sb_master_dir.no_formal_ino);
str 241 fs/gfs2/ops_fstype.c sb->sb_root_dir.no_addr = be64_to_cpu(str->sb_root_dir.no_addr);
str 242 fs/gfs2/ops_fstype.c sb->sb_root_dir.no_formal_ino = be64_to_cpu(str->sb_root_dir.no_formal_ino);
str 244 fs/gfs2/ops_fstype.c memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN);
str 245 fs/gfs2/ops_fstype.c memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN);
str 437 fs/gfs2/ops_inode.c struct qstr str;
str 439 fs/gfs2/ops_inode.c gfs2_str2qstr(&str, ".");
str 441 fs/gfs2/ops_inode.c gfs2_qstr2dirent(&str, GFS2_DIRENT_SIZE(str.len), dent);
str 446 fs/gfs2/ops_inode.c gfs2_str2qstr(&str, "..");
str 448 fs/gfs2/ops_inode.c gfs2_qstr2dirent(&str, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);
str 578 fs/gfs2/quota.c const struct gfs2_quota *str = buf;
str 580 fs/gfs2/quota.c qu->qu_limit = be64_to_cpu(str->qu_limit);
str 581 fs/gfs2/quota.c qu->qu_warn = be64_to_cpu(str->qu_warn);
str 582 fs/gfs2/quota.c qu->qu_value = be64_to_cpu(str->qu_value);
str 583 fs/gfs2/quota.c qu->qu_ll_next = be32_to_cpu(str->qu_ll_next);
str 588 fs/gfs2/quota.c struct gfs2_quota *str = buf;
str 590 fs/gfs2/quota.c str->qu_limit = cpu_to_be64(qu->qu_limit);
str 591 fs/gfs2/quota.c str->qu_warn = cpu_to_be64(qu->qu_warn);
str 592 fs/gfs2/quota.c str->qu_value = cpu_to_be64(qu->qu_value);
str 593 fs/gfs2/quota.c str->qu_ll_next = cpu_to_be32(qu->qu_ll_next);
str 594 fs/gfs2/quota.c memset(&str->qu_reserved, 0, sizeof(str->qu_reserved));
str 1093 fs/gfs2/quota.c const struct gfs2_quota_change *str = buf;
str 1095 fs/gfs2/quota.c qc->qc_change = be64_to_cpu(str->qc_change);
str 1096 fs/gfs2/quota.c qc->qc_flags = be32_to_cpu(str->qc_flags);
str 1097 fs/gfs2/quota.c qc->qc_id = be32_to_cpu(str->qc_id);
str 120 fs/gfs2/recovery.c const struct gfs2_log_header *str = buf;
str 122 fs/gfs2/recovery.c if (str->lh_header.mh_magic != cpu_to_be32(GFS2_MAGIC) ||
str 123 fs/gfs2/recovery.c str->lh_header.mh_type != cpu_to_be32(GFS2_METATYPE_LH))
str 126 fs/gfs2/recovery.c lh->lh_sequence = be64_to_cpu(str->lh_sequence);
str 127 fs/gfs2/recovery.c lh->lh_flags = be32_to_cpu(str->lh_flags);
str 128 fs/gfs2/recovery.c lh->lh_tail = be32_to_cpu(str->lh_tail);
str 129 fs/gfs2/recovery.c lh->lh_blkno = be32_to_cpu(str->lh_blkno);
str 130 fs/gfs2/recovery.c lh->lh_hash = be32_to_cpu(str->lh_hash);
str 518 fs/gfs2/rgrp.c const struct gfs2_rindex *str = buf;
str 520 fs/gfs2/rgrp.c rgd->rd_addr = be64_to_cpu(str->ri_addr);
str 521 fs/gfs2/rgrp.c rgd->rd_length = be32_to_cpu(str->ri_length);
str 522 fs/gfs2/rgrp.c rgd->rd_data0 = be64_to_cpu(str->ri_data0);
str 523 fs/gfs2/rgrp.c rgd->rd_data = be32_to_cpu(str->ri_data);
str 524 fs/gfs2/rgrp.c rgd->rd_bitbytes = be32_to_cpu(str->ri_bitbytes);
str 694 fs/gfs2/rgrp.c const struct gfs2_rgrp *str = buf;
str 698 fs/gfs2/rgrp.c rg_flags = be32_to_cpu(str->rg_flags);
str 703 fs/gfs2/rgrp.c rg->rg_free = be32_to_cpu(str->rg_free);
str 704 fs/gfs2/rgrp.c rg->rg_dinodes = be32_to_cpu(str->rg_dinodes);
str 705 fs/gfs2/rgrp.c rg->rg_igeneration = be64_to_cpu(str->rg_igeneration);
str 710 fs/gfs2/rgrp.c struct gfs2_rgrp *str = buf;
str 716 fs/gfs2/rgrp.c str->rg_flags = cpu_to_be32(rg_flags);
str 717 fs/gfs2/rgrp.c str->rg_free = cpu_to_be32(rg->rg_free);
str 718 fs/gfs2/rgrp.c str->rg_dinodes = cpu_to_be32(rg->rg_dinodes);
str 719 fs/gfs2/rgrp.c str->__pad = cpu_to_be32(0);
str 720 fs/gfs2/rgrp.c str->rg_igeneration = cpu_to_be64(rg->rg_igeneration);
str 721 fs/gfs2/rgrp.c memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
str 279 fs/gfs2/super.c const struct gfs2_statfs_change *str = buf;
str 281 fs/gfs2/super.c sc->sc_total = be64_to_cpu(str->sc_total);
str 282 fs/gfs2/super.c sc->sc_free = be64_to_cpu(str->sc_free);
str 283 fs/gfs2/super.c sc->sc_dinodes = be64_to_cpu(str->sc_dinodes);
str 288 fs/gfs2/super.c struct gfs2_statfs_change *str = buf;
str 290 fs/gfs2/super.c str->sc_total = cpu_to_be64(sc->sc_total);
str 291 fs/gfs2/super.c str->sc_free = cpu_to_be64(sc->sc_free);
str 292 fs/gfs2/super.c str->sc_dinodes = cpu_to_be64(sc->sc_dinodes);
str 90 fs/hfs/catalog.c dprint(DBG_CAT_MOD, "create_cat: %s,%u(%d)\n", str->name, cnid, inode->i_nlink);
str 100 fs/hfs/catalog.c dir->i_ino, str);
str 111 fs/hfs/catalog.c hfs_cat_build_key(sb, fd.search_key, dir->i_ino, str);
str 211 fs/hfs/catalog.c dprint(DBG_CAT_MOD, "delete_cat: %s,%u\n", str ? str->name : NULL, cnid);
str 215 fs/hfs/catalog.c hfs_cat_build_key(sb, fd.search_key, dir->i_ino, str);
str 47 fs/hfsplus/catalog.c if (str) {
str 48 fs/hfsplus/catalog.c hfsplus_asc2uni(sb, &key->cat.name, str->name, str->len);
str 148 fs/hfsplus/catalog.c hfsplus_asc2uni(sb, &entry->thread.nodeName, str->name, str->len);
str 184 fs/hfsplus/catalog.c dprint(DBG_CAT_MOD, "create_cat: %s,%u(%d)\n", str->name, cnid, inode->i_nlink);
str 191 fs/hfsplus/catalog.c dir->i_ino, str);
str 202 fs/hfsplus/catalog.c hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, str);
str 239 fs/hfsplus/catalog.c dprint(DBG_CAT_MOD, "delete_cat: %s,%u\n", str ? str->name : NULL, cnid);
str 243 fs/hfsplus/catalog.c if (!str) {
str 258 fs/hfsplus/catalog.c hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, str);
str 74 fs/hfsplus/dir.c struct qstr str;
str 87 fs/hfsplus/dir.c str.len = sprintf(name, "iNode%d", linkid);
str 88 fs/hfsplus/dir.c str.name = name;
str 89 fs/hfsplus/dir.c hfsplus_cat_build_key(sb, fd.search_key, HFSPLUS_SB(sb).hidden_dir->i_ino, &str);
str 266 fs/hfsplus/dir.c struct qstr str;
str 278 fs/hfsplus/dir.c str.name = name;
str 279 fs/hfsplus/dir.c str.len = sprintf(name, "iNode%d", id);
str 282 fs/hfsplus/dir.c HFSPLUS_SB(sb).hidden_dir, &str);
str 317 fs/hfsplus/dir.c struct qstr str;
str 328 fs/hfsplus/dir.c str.name = name;
str 329 fs/hfsplus/dir.c str.len = sprintf(name, "temp%lu", inode->i_ino);
str 332 fs/hfsplus/dir.c HFSPLUS_SB(sb).hidden_dir, &str);
str 291 fs/hfsplus/super.c struct qstr str;
str 401 fs/hfsplus/super.c str.len = sizeof(HFSP_HIDDENDIR_NAME) - 1;
str 402 fs/hfsplus/super.c str.name = HFSP_HIDDENDIR_NAME;
str 404 fs/hfsplus/super.c hfsplus_cat_build_key(sb, fd.search_key, HFSPLUS_ROOT_CNID, &str);
str 436 fs/hfsplus/super.c &str, HFSPLUS_SB(sb).hidden_dir);
str 336 fs/hfsplus/unicode.c astr = str->name;
str 337 fs/hfsplus/unicode.c len = str->len;
str 356 fs/hfsplus/unicode.c str->hash = end_name_hash(hash);
str 1359 fs/inode.c if (!str)
str 1361 fs/inode.c ihash_entries = simple_strtoul(str, &str, 0);
str 751 fs/namespace.c const char *str;
str 766 fs/namespace.c seq_puts(m, fs_infop->str);
str 787 fs/namespace.c seq_puts(m, fs_infop->str);
str 77 fs/nfs/callback_xdr.c *str = (const char *)p;
str 79 fs/nfs/callback_xdr.c *str = NULL;
str 214 fs/nfs/callback_xdr.c xdr_encode_opaque(p, str, len);
str 578 fs/nfs/nfs4xdr.c xdr_encode_opaque(p, str, len);
str 2253 fs/nfs/nfs4xdr.c char *str;
str 2256 fs/nfs/nfs4xdr.c return decode_opaque_inline(xdr, &strlen, &str);
str 422 fs/nfs/super.c const char *str;
str 443 fs/nfs/super.c return sec_flavours[i].str;
str 495 fs/nfs/super.c const char *str;
str 529 fs/nfs/super.c seq_puts(m, nfs_infop->str);
str 48 fs/nfs/unlink.c char *str;
str 51 fs/nfs/unlink.c str = kmemdup(dentry->d_name.name, NAME_ALLOC_LEN(len), GFP_KERNEL);
str 52 fs/nfs/unlink.c if (!str)
str 55 fs/nfs/unlink.c data->args.name.name = str;
str 79 fs/nfsd/nfs4xdr.c if (isdotent(str, len))
str 82 fs/nfsd/nfs4xdr.c if (str[i] == '/')
str 1229 fs/nfsd/nfs4xdr.c char *str, *end;
str 1235 fs/nfsd/nfs4xdr.c end = str = components;
str 1239 fs/nfsd/nfs4xdr.c strlen = end - str;
str 1244 fs/nfsd/nfs4xdr.c WRITEMEM(str, strlen);
str 1249 fs/nfsd/nfs4xdr.c str = end;
str 2326 fs/ntfs/inode.c seq_printf(sf, ",errors=%s", on_errors_arr[i].str);
str 98 fs/ntfs/ntfs.h char *str;
str 153 fs/ntfs/super.c for (_i = 0; opt_array[_i].str && *opt_array[_i].str; _i++) \
str 154 fs/ntfs/super.c if (!strcmp(opt_array[_i].str, v)) { \
str 158 fs/ntfs/super.c if (!opt_array[_i].str || !*opt_array[_i].str) \
str 48 fs/ubifs/key.h const signed char *str = (const signed char *)s;
str 50 fs/ubifs/key.h while (*str) {
str 51 fs/ubifs/key.h a += *str << 4;
str 52 fs/ubifs/key.h a += *str >> 4;
str 54 fs/ubifs/key.h str++;
str 79 fs/ubifs/key.h memcpy(&a, str, len);
str 1194 fs/ubifs/ubifs.h uint32_t (*key_hash)(const char *str, int len);
str 467 fs/xfs/linux-2.6/xfs_super.c char *str;
str 502 fs/xfs/linux-2.6/xfs_super.c seq_puts(m, xfs_infop->str);
str 506 fs/xfs/linux-2.6/xfs_super.c seq_puts(m, xfs_infop->str);
str 430 fs/xfs/xfs_alloc.c (void *)str,
str 467 fs/xfs/xfs_alloc.c (void *)str,
str 491 fs/xfs/xfs_alloc.c (void *)str,
str 523 fs/xfs/xfs_alloc.c (void *)str,
str 1971 fs/xfs/xfs_log_recover.c str, id, be16_to_cpu(ddq->d_magic), XFS_DQUOT_MAGIC);
str 1978 fs/xfs/xfs_log_recover.c str, id, ddq->d_version, XFS_DQUOT_VERSION);
str 1988 fs/xfs/xfs_log_recover.c str, id, ddq->d_flags);
str 1997 fs/xfs/xfs_log_recover.c str, ddq, id, be32_to_cpu(ddq->d_id));
str 2010 fs/xfs/xfs_log_recover.c str, (int)be32_to_cpu(ddq->d_id), ddq);
str 2022 fs/xfs/xfs_log_recover.c str, (int)be32_to_cpu(ddq->d_id), ddq);
str 2034 fs/xfs/xfs_log_recover.c str, (int)be32_to_cpu(ddq->d_id), ddq);
str 400 include/asm-cris/uaccess.h #define strlen_user(str) strnlen_user((str), 0x7ffffffe)
str 121 include/asm-frv/math-emu.h "fpu instruction (%s)\n", str); \
str 317 include/asm-frv/uaccess.h #define strlen_user(str) strnlen_user(str, 32767)
str 690 include/asm-m32r/uaccess.h #define strlen_user(str) strnlen_user(str, ~0UL >> 1)
str 121 include/asm-m68k/math-emu.h "fpu instruction (%s)\n", str); \
str 217 include/asm-m68k/openprom.h void (*pv_putstr)(char *str, int len);
str 229 include/asm-m68k/openprom.h void (*v0_eval)(int len, char *str);
str 230 include/asm-m68k/openprom.h void (*v2_eval)(char *str);
str 372 include/asm-m68k/uaccess.h #define strlen_user(str) strnlen_user(str, 32767)
str 486 include/asm-mn10300/uaccess.h #define strlen_user(str) strnlen_user(str, ~0UL >> 1)
str 231 include/asm-parisc/uaccess.h #define strlen_user(str) lstrnlen_user(str, 0x7fffffffL)
str 91 include/asm-um/uaccess.h #define strlen_user(str) strnlen_user(str, ~0U >> 1)
str 212 include/asm-x86/uaccess_32.h #define strlen_user(str) strnlen_user(str, LONG_MAX)
str 343 include/asm-x86/xen/hypercall.h return _hypercall3(int, console_io, cmd, count, str);
str 466 include/asm-xtensa/uaccess.h #define strlen_user(str) strnlen_user((str), TASK_SIZE - 1)
str 477 include/asm-xtensa/uaccess.h if ((unsigned long)str > top)
str 479 include/asm-xtensa/uaccess.h return __strnlen_user(str, len);
str 167 include/linux/hp_sdc.h case 0x1: str = "1820-3712"; break; \
str 168 include/linux/hp_sdc.h case 0x2: str = "1820-4379"; break; \
str 169 include/linux/hp_sdc.h case 0x3: str = "1820-4784"; break; \
str 170 include/linux/hp_sdc.h default: str = "unknown"; \
str 218 include/linux/init.h const char *str;
str 230 include/linux/init.h static char __setup_str_##unique_id[] __initdata __aligned(1) = str; \
str 237 include/linux/init.h __setup_param(str, unique_id, NULL, 0)
str 240 include/linux/init.h __setup_param(str, fn, fn, 0)
str 245 include/linux/init.h __setup_param(str, fn, fn, 1)
str 10 include/linux/kbuild.h DEFINE(sym, offsetof(struct str, mem))
str 10 include/linux/kdebug.h const char *str;
str 43 include/linux/moduleparam.h const struct kparam_string *str;
str 108 include/linux/moduleparam.h .str = &__param_string_##name, perm); \
str 91 include/linux/parport_pc.h printk (KERN_DEBUG "*** parport state (%s): ecr=[%s", str, ecr_modes[(ecr & 0xe0) >> 5]);
str 613 include/linux/rtnetlink.h int len = strlen(str) + 1;
str 614 include/linux/rtnetlink.h return len > rta->rta_len || memcmp(RTA_DATA(rta), str, len);
str 212 include/linux/tipc_config.h char str[TIPC_MAX_LINK_NAME]; /* link name */
str 69 include/net/9p/9p.h fcall?fcall->params.rerror.error.str:"");
str 277 include/net/9p/9p.h char *str;
str 803 include/net/netlink.h return nla_put(skb, attrtype, strlen(str) + 1, str);
str 306 include/net/sctp/sctp.h str, (#expr), __FILE__, __FUNCTION__, __LINE__); \
str 88 include/pcmcia/cistpl.h char str[254];
str 129 include/pcmcia/cistpl.h char str[254];
str 507 include/pcmcia/cistpl.h char str[244];
str 192 include/xen/xenbus.h if (!IS_ERR(str) && strlen(str) == 0) { \
str 193 include/xen/xenbus.h kfree(str); \
str 194 include/xen/xenbus.h str = ERR_PTR(-ERANGE); \
str 196 include/xen/xenbus.h IS_ERR(str); \
str 17 init/calibrate.c preset_lpj = simple_strtoul(str,NULL,0);
str 34 init/do_mounts.c rd_doload = simple_strtol(str,NULL,0) & 3;
str 41 init/do_mounts.c if (*str)
str 49 init/do_mounts.c if (*str)
str 155 init/do_mounts.c if (*str)
str 166 init/do_mounts.c root_mount_data = str;
str 173 init/do_mounts.c root_fs_names = str;
str 180 init/do_mounts.c root_delay = simple_strtoul(str, NULL, 0);
str 59 init/do_mounts_md.c if (*str == 'd') {
str 61 init/do_mounts_md.c str++;
str 63 init/do_mounts_md.c if (get_option(&str, &minor) != 2) { /* MD Number */
str 67 init/do_mounts_md.c str1 = str;
str 81 init/do_mounts_md.c switch (get_option(&str, &level)) { /* RAID level */
str 84 init/do_mounts_md.c if (get_option(&str, &factor) != 2 || /* Chunk Size */
str 85 init/do_mounts_md.c get_option(&str, &fault) != 2) {
str 99 init/do_mounts_md.c str = str1;
str 107 init/do_mounts_md.c minor, pername, str);
str 108 init/do_mounts_md.c md_setup_args[ent].device_names = str;
str 248 init/do_mounts_md.c len = strlen(str) + 1;
str 252 init/do_mounts_md.c char *comma = strchr(str+pos, ',');
str 255 init/do_mounts_md.c wlen = (comma-str)-pos;
str 258 init/do_mounts_md.c if (!strncmp(str, "noautodetect", wlen))
str 260 init/do_mounts_md.c if (!strncmp(str, "autodetect", wlen))
str 262 init/do_mounts_md.c if (strncmp(str, "partitionable", wlen)==0)
str 264 init/do_mounts_md.c if (strncmp(str, "part", wlen)==0)
str 17 init/do_mounts_rd.c rd_prompt = simple_strtol(str,NULL,0) & 1;
str 26 init/do_mounts_rd.c rd_image_start = simple_strtol(str,NULL,0);
str 480 init/initramfs.c if (*str)
str 158 init/main.c get_option(&str, &setup_max_cpus);
str 203 init/main.c int n = strlen(p->str);
str 204 init/main.c if (!strncmp(line, p->str, n)) {
str 214 init/main.c " ignored\n", p->str);
str 250 init/main.c get_option(&str, &console_loglevel);
str 325 init/main.c execute_command = str;
str 342 init/main.c ramdisk_execute_command = str;
str 490 init/main.c if ((p->early && strcmp(param, p->str) == 0) ||
str 492 init/main.c strcmp(p->str, "earlycon") == 0)
str 1001 kernel/audit.c audit_default = !!simple_strtol(str, NULL, 0);
str 219 kernel/auditfilter.c char *str;
str 230 kernel/auditfilter.c str = kmalloc(len + 1, GFP_KERNEL);
str 231 kernel/auditfilter.c if (unlikely(!str))
str 234 kernel/auditfilter.c memcpy(str, *bufp, len);
str 235 kernel/auditfilter.c str[len] = 0;
str 239 kernel/auditfilter.c return str;
str 537 kernel/auditfilter.c char *str;
str 594 kernel/auditfilter.c str = audit_unpack_string(&bufp, &remain, f->val);
str 595 kernel/auditfilter.c if (IS_ERR(str))
str 599 kernel/auditfilter.c err = security_audit_rule_init(f->type, f->op, str,
str 605 kernel/auditfilter.c "\'%s\' is invalid\n", str);
str 609 kernel/auditfilter.c kfree(str);
str 612 kernel/auditfilter.c f->lsm_str = str;
str 615 kernel/auditfilter.c str = audit_unpack_string(&bufp, &remain, f->val);
str 616 kernel/auditfilter.c if (IS_ERR(str))
str 620 kernel/auditfilter.c err = audit_to_watch(&entry->rule, str, f->val, f->op);
str 622 kernel/auditfilter.c kfree(str);
str 627 kernel/auditfilter.c str = audit_unpack_string(&bufp, &remain, f->val);
str 628 kernel/auditfilter.c if (IS_ERR(str))
str 632 kernel/auditfilter.c err = audit_make_tree(&entry->rule, str, f->op);
str 633 kernel/auditfilter.c kfree(str);
str 646 kernel/auditfilter.c str = audit_unpack_string(&bufp, &remain, f->val);
str 647 kernel/auditfilter.c if (IS_ERR(str))
str 650 kernel/auditfilter.c entry->rule.filterkey = str;
str 689 kernel/auditfilter.c size_t len = strlen(str);
str 691 kernel/auditfilter.c memcpy(*bufp, str, len);
str 3104 kernel/cgroup.c while ((token = strsep(&str, ",")) != NULL) {
str 474 kernel/hrtimer.c if (!strcmp(str, "off"))
str 476 kernel/hrtimer.c else if (!strcmp(str, "on"))
str 458 kernel/lockdep.c return kallsyms_lookup((unsigned long)key, NULL, NULL, NULL, str);
str 497 kernel/lockdep.c char str[KSYM_NAME_LEN], c1, c2, c3, c4;
str 504 kernel/lockdep.c name = __get_key_name(class->key, str);
str 519 kernel/lockdep.c char str[KSYM_NAME_LEN];
str 523 kernel/lockdep.c name = __get_key_name(lock->key->subkeys, str);
str 68 kernel/lockdep_proc.c char str[128];
str 72 kernel/lockdep_proc.c name = __get_key_name(class->key, str);
str 513 kernel/lockdep_proc.c char str[KSYM_NAME_LEN];
str 516 kernel/lockdep_proc.c key_name = __get_key_name(class->key, str);
str 2344 kernel/module.c return str[0] == '$' && strchr("atd", str[1])
str 2345 kernel/module.c && (str[2] == '\0' || str[2] == '.');
str 558 kernel/notifier.c .str = str,
str 39 kernel/panic.c panic_timeout = simple_strtoul(str, NULL, 0);
str 192 kernel/panic.c pause_on_oops = simple_strtoul(str, NULL, 0);
str 354 kernel/params.c const struct kparam_string *kps = kp->str;
str 371 kernel/params.c const struct kparam_string *kps = kp->str;
str 865 kernel/power/disk.c strncpy( resume_file, str, 255 );
str 876 kernel/power/disk.c if (sscanf(str, "%llu", &offset) == 1)
str 141 kernel/printk.c unsigned size = memparse(str, &str);
str 193 kernel/printk.c get_option(&str, &boot_delay);
str 836 kernel/printk.c if (!memcmp(str, "brl,", 4)) {
str 838 kernel/printk.c str += 4;
str 839 kernel/printk.c } else if (!memcmp(str, "brl=", 4)) {
str 840 kernel/printk.c brl_options = str + 4;
str 841 kernel/printk.c str = strchr(brl_options, ',');
str 842 kernel/printk.c if (!str) {
str 846 kernel/printk.c *(str++) = 0;
str 853 kernel/printk.c if (str[0] >= '0' && str[0] <= '9') {
str 855 kernel/printk.c strncpy(buf + 4, str, sizeof(buf) - 5);
str 857 kernel/printk.c strncpy(buf, str, sizeof(buf) - 1);
str 860 kernel/printk.c if ((options = strchr(str, ',')) != NULL)
str 863 kernel/printk.c if (!strcmp(str, "ttya"))
str 865 kernel/printk.c if (!strcmp(str, "ttyb"))
str 60 kernel/profile.c if (!strncmp(str, sleepstr, strlen(sleepstr))) {
str 63 kernel/profile.c if (str[strlen(sleepstr)] == ',')
str 64 kernel/profile.c str += strlen(sleepstr) + 1;
str 65 kernel/profile.c if (get_option(&str, &par))
str 74 kernel/profile.c } else if (!strncmp(str, schedstr, strlen(schedstr))) {
str 76 kernel/profile.c if (str[strlen(schedstr)] == ',')
str 77 kernel/profile.c str += strlen(schedstr) + 1;
str 78 kernel/profile.c if (get_option(&str, &par))
str 83 kernel/profile.c } else if (!strncmp(str, kvmstr, strlen(kvmstr))) {
str 85 kernel/profile.c if (str[strlen(kvmstr)] == ',')
str 86 kernel/profile.c str += strlen(kvmstr) + 1;
str 87 kernel/profile.c if (get_option(&str, &par))
str 92 kernel/profile.c } else if (get_option(&str, &par)) {
str 815 kernel/resource.c if (get_option (&str, &io_start) != 2)
str 817 kernel/resource.c if (get_option (&str, &io_num) == 0)
str 6649 kernel/sched.c char str[256];
str 6651 kernel/sched.c cpulist_scnprintf(str, sizeof(str), sd->span);
str 6665 kernel/sched.c str, sd_level_to_string(sd->level));
str 6705 kernel/sched.c cpulist_scnprintf(str, sizeof(str), group->cpumask);
str 6706 kernel/sched.c printk(KERN_CONT " %s", str);
str 6908 kernel/sched.c str = get_options(str, ARRAY_SIZE(ints), ints);
str 7337 kernel/sched.c val = simple_strtoul(str, NULL, 0);
str 898 kernel/signal.c get_option (&str, &print_fatal_signals);
str 40 kernel/softlockup.c softlockup_panic = simple_strtoul(str, NULL, 0);
str 1392 kernel/sysctl_check.c *fail = str;
str 524 kernel/time/clocksource.c if (str)
str 525 kernel/time/clocksource.c strlcpy(override_name, str, sizeof(override_name));
str 541 kernel/time/clocksource.c if (!strcmp(str, "pmtmr")) {
str 548 kernel/time/clocksource.c return boot_override_clocksource(str);
str 440 kernel/time/ntp.c ntp_tick_adj = simple_strtol(str, NULL, 0);
str 116 kernel/time/tick-sched.c if (!strcmp(str, "off"))
str 118 kernel/time/tick-sched.c else if (!strcmp(str, "on"))
str 959 kernel/trace/ftrace.c char str[KSYM_SYMBOL_LEN];
str 964 kernel/trace/ftrace.c kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
str 966 kernel/trace/ftrace.c seq_printf(m, "%s\n", str);
str 1141 kernel/trace/ftrace.c char str[KSYM_SYMBOL_LEN];
str 1181 kernel/trace/ftrace.c kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
str 1184 kernel/trace/ftrace.c if (strcmp(str, buff) == 0)
str 1188 kernel/trace/ftrace.c if (memcmp(str, buff, match) == 0)
str 1192 kernel/trace/ftrace.c if (strstr(str, search))
str 1196 kernel/trace/ftrace.c ptr = strstr(str, search);
str 177 kernel/trace/trace.c if (!str)
str 179 kernel/trace/trace.c ret = strict_strtoul(str, 0, &nr_entries);
str 364 kernel/trace/trace.c int len = strlen(str);
str 369 kernel/trace/trace.c memcpy(s->buffer + s->len, str, len);
str 1282 kernel/trace/trace.c char str[KSYM_SYMBOL_LEN];
str 1284 kernel/trace/trace.c kallsyms_lookup(address, NULL, NULL, NULL, str);
str 1286 kernel/trace/trace.c return trace_seq_printf(s, fmt, str);
str 1296 kernel/trace/trace.c char str[KSYM_SYMBOL_LEN];
str 1298 kernel/trace/trace.c sprint_symbol(str, address);
str 1299 kernel/trace/trace.c return trace_seq_printf(s, fmt, str);
str 30 lib/argv_split.c while (*str) {
str 31 lib/argv_split.c str = skip_sep(str);
str 32 lib/argv_split.c if (*str) {
str 34 lib/argv_split.c str = skip_arg(str);
str 72 lib/argv_split.c int argc = count_argc(str);
str 84 lib/argv_split.c while (*str) {
str 85 lib/argv_split.c str = skip_sep(str);
str 87 lib/argv_split.c if (*str) {
str 88 lib/argv_split.c const char *p = str;
str 91 lib/argv_split.c str = skip_arg(str);
str 93 lib/argv_split.c t = kstrndup(p, str-p, gfp);
str 29 lib/cmdline.c (*str)++;
str 30 lib/cmdline.c upper_range = simple_strtol((*str), NULL, 0);
str 54 lib/cmdline.c char *cur = *str;
str 58 lib/cmdline.c *pint = simple_strtol (cur, str, 0);
str 59 lib/cmdline.c if (cur == *str)
str 61 lib/cmdline.c if (**str == ',') {
str 62 lib/cmdline.c (*str)++;
str 65 lib/cmdline.c if (**str == '-')
str 93 lib/cmdline.c res = get_option ((char **)&str, ints + i);
str 98 lib/cmdline.c range_nums = get_range((char **)&str, ints + i);
str 113 lib/cmdline.c return (char *)str;
str 26 lib/fault-inject.c if (sscanf(str, "%lu,%lu,%d,%d",
str 32 lib/locking-selftest.c get_option(&str, &debug_locks_verbose);
str 115 lib/swiotlb.c if (isdigit(*str)) {
str 116 lib/swiotlb.c io_tlb_nslabs = simple_strtoul(str, &str, 0);
str 120 lib/swiotlb.c if (*str == ',')
str 121 lib/swiotlb.c ++str;
str 122 lib/swiotlb.c if (!strcmp(str, "force"))
str 583 lib/vsprintf.c char *str, *end, c;
str 605 lib/vsprintf.c str = buf;
str 616 lib/vsprintf.c if (str < end)
str 617 lib/vsprintf.c *str = *fmt;
str 618 lib/vsprintf.c ++str;
str 682 lib/vsprintf.c if (str < end)
str 683 lib/vsprintf.c *str = ' ';
str 684 lib/vsprintf.c ++str;
str 688 lib/vsprintf.c if (str < end)
str 689 lib/vsprintf.c *str = c;
str 690 lib/vsprintf.c ++str;
str 692 lib/vsprintf.c if (str < end)
str 693 lib/vsprintf.c *str = ' ';
str 694 lib/vsprintf.c ++str;
str 699 lib/vsprintf.c str = string(str, end, va_arg(args, char *), field_width, precision, flags);
str 703 lib/vsprintf.c str = pointer(fmt+1, str, end,
str 716 lib/vsprintf.c *ip = (str - buf);
str 719 lib/vsprintf.c *ip = (str - buf);
str 722 lib/vsprintf.c *ip = (str - buf);
str 727 lib/vsprintf.c if (str < end)
str 728 lib/vsprintf.c *str = '%';
str 729 lib/vsprintf.c ++str;
str 750 lib/vsprintf.c if (str < end)
str 751 lib/vsprintf.c *str = '%';
str 752 lib/vsprintf.c ++str;
str 754 lib/vsprintf.c if (str < end)
str 755 lib/vsprintf.c *str = *fmt;
str 756 lib/vsprintf.c ++str;
str 781 lib/vsprintf.c str = number(str, end, num, base,
str 785 lib/vsprintf.c if (str < end)
str 786 lib/vsprintf.c *str = '\0';
str 791 lib/vsprintf.c return str-buf;
str 919 lib/vsprintf.c const char *str = buf;
str 928 lib/vsprintf.c while(*fmt && *str) {
str 936 lib/vsprintf.c while (isspace(*str))
str 937 lib/vsprintf.c ++str;
str 942 lib/vsprintf.c if (*fmt++ != *str++)
str 957 lib/vsprintf.c while (!isspace(*str) && *str)
str 958 lib/vsprintf.c str++;
str 985 lib/vsprintf.c if (!*fmt || !*str)
str 995 lib/vsprintf.c *s++ = *str++;
str 996 lib/vsprintf.c } while (--field_width > 0 && *str);
str 1006 lib/vsprintf.c while (isspace(*str))
str 1007 lib/vsprintf.c str++;
str 1010 lib/vsprintf.c while (*str && !isspace(*str) && field_width--) {
str 1011 lib/vsprintf.c *s++ = *str++;
str 1021 lib/vsprintf.c *i = str - buf;
str 1039 lib/vsprintf.c if (*str++ != '%')
str 1050 lib/vsprintf.c while (isspace(*str))
str 1051 lib/vsprintf.c str++;
str 1053 lib/vsprintf.c digit = *str;
str 1055 lib/vsprintf.c digit = *(str + 1);
str 1068 lib/vsprintf.c *s = (signed char) simple_strtol(str,&next,base);
str 1071 lib/vsprintf.c *s = (unsigned char) simple_strtoul(str, &next, base);
str 1077 lib/vsprintf.c *s = (short) simple_strtol(str,&next,base);
str 1080 lib/vsprintf.c *s = (unsigned short) simple_strtoul(str, &next, base);
str 1086 lib/vsprintf.c *l = simple_strtol(str,&next,base);
str 1089 lib/vsprintf.c *l = simple_strtoul(str,&next,base);
str 1095 lib/vsprintf.c *l = simple_strtoll(str,&next,base);
str 1098 lib/vsprintf.c *l = simple_strtoull(str,&next,base);
str 1105 lib/vsprintf.c *s = (size_t) simple_strtoul(str,&next,base);
str 1111 lib/vsprintf.c *i = (int) simple_strtol(str,&next,base);
str 1114 lib/vsprintf.c *i = (unsigned int) simple_strtoul(str,&next,base);
str 1122 lib/vsprintf.c str = next;
str 1132 lib/vsprintf.c *p = str - buf;
str 154 lib/zlib_deflate/deflate.c (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
str 155 lib/zlib_deflate/deflate.c s->prev[(str) & s->w_mask] = match_head = s->head[s->ins_h], \
str 156 lib/zlib_deflate/deflate.c s->head[s->ins_h] = (Pos)(str))
str 1997 mm/mempolicy.c char *nodelist = strchr(str, ':');
str 1998 mm/mempolicy.c char *flags = strchr(str, '=');
str 2016 mm/mempolicy.c if (!strcmp(str, policy_types[i])) {
str 134 mm/mm_init.c get_option(&str, &mminit_loglevel);
str 1140 mm/page_alloc.c return setup_fault_attr(&fail_page_alloc.attr, str);
str 4389 mm/page_alloc.c if (!str)
str 4391 mm/page_alloc.c hashdist = simple_strtoul(str, &str, 0);
str 3126 mm/slab.c return setup_fault_attr(&failslab.attr, str);
str 958 mm/slub.c if (*str++ != '=' || !*str)
str 964 mm/slub.c if (*str == ',')
str 972 mm/slub.c if (*str == '-')
str 981 mm/slub.c for (; *str && *str != ','; str++) {
str 982 mm/slub.c switch (tolower(*str)) {
str 1000 mm/slub.c "unknown. skipped\n", *str);
str 1005 mm/slub.c if (*str == ',')
str 1006 mm/slub.c slub_debug_slabs = str + 1;
str 2475 mm/slub.c get_option(&str, &slub_min_order);
str 2484 mm/slub.c get_option(&str, &slub_max_order);
str 2493 mm/slub.c get_option(&str, &slub_min_objects);
str 205 net/9p/client.c if (version->len == 8 && !memcmp(version->str, "9P2000.u", 8))
str 207 net/9p/client.c else if (version->len == 6 && !memcmp(version->str, "9P2000", 6))
str 1015 net/9p/client.c memmove(p, st->name.str, st->name.len);
str 1016 net/9p/client.c ret->name.str = p;
str 1018 net/9p/client.c memmove(p, st->uid.str, st->uid.len);
str 1019 net/9p/client.c ret->uid.str = p;
str 1021 net/9p/client.c memmove(p, st->gid.str, st->gid.len);
str 1022 net/9p/client.c ret->gid.str = p;
str 1024 net/9p/client.c memmove(p, st->muid.str, st->muid.len);
str 1025 net/9p/client.c ret->muid.str = p;
str 1029 net/9p/client.c memmove(p, st->extension.str, st->extension.len);
str 1030 net/9p/client.c ret->extension.str = p;
str 183 net/9p/conv.c vstr->str = buf->p;
str 187 net/9p/conv.c vstr->str = NULL;
str 443 net/9p/conv.c if (str) {
str 444 net/9p/conv.c str->len = len;
str 445 net/9p/conv.c str->str = s;
str 93 net/9p/fcprint.c st->name.str, st->uid.len, st->uid.str);
str 97 net/9p/fcprint.c n += scnprintf(buf+n, buflen-n, " '%.*s'", st->gid.len, st->gid.str);
str 101 net/9p/fcprint.c n += scnprintf(buf+n, buflen-n, " '%.*s'", st->muid.len, st->muid.str);
str 114 net/9p/fcprint.c st->extension.len, st->extension.str);
str 171 net/9p/fcprint.c fc->params.tversion.version.str);
str 179 net/9p/fcprint.c fc->params.rversion.version.str);
str 186 net/9p/fcprint.c fc->params.tauth.uname.str, fc->params.tauth.aname.len,
str 187 net/9p/fcprint.c fc->params.tauth.aname.str);
str 199 net/9p/fcprint.c fc->params.tattach.uname.len, fc->params.tattach.uname.str,
str 200 net/9p/fcprint.c fc->params.tattach.aname.len, fc->params.tattach.aname.str);
str 213 net/9p/fcprint.c fc->params.rerror.error.str);
str 236 net/9p/fcprint.c fc->params.twalk.wnames[i].str);
str 264 net/9p/fcprint.c fc->params.tcreate.name.str);
str 668 net/9p/trans_fd.c ename->str);
str 674 net/9p/trans_fd.c req->err = p9_errstr2errno(ename->str, ename->len);
str 2425 net/bluetooth/l2cap.c char *str = buf;
str 2432 net/bluetooth/l2cap.c str += sprintf(str, "%s %s %d %d 0x%4.4x 0x%4.4x %d %d 0x%x\n",
str 2440 net/bluetooth/l2cap.c return (str - buf);
str 49 net/bluetooth/lib.c static char str[2][18];
str 53 net/bluetooth/lib.c sprintf(str[i], "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X",
str 57 net/bluetooth/lib.c return str[i];
str 2041 net/bluetooth/rfcomm/core.c char *str = buf;
str 2051 net/bluetooth/rfcomm/core.c str += sprintf(str, "%s %s %ld %d %d %d %d\n",
str 2059 net/bluetooth/rfcomm/core.c return (str - buf);
str 903 net/bluetooth/rfcomm/sock.c char *str = buf;
str 908 net/bluetooth/rfcomm/sock.c str += sprintf(str, "%s %s %d %d\n",
str 915 net/bluetooth/rfcomm/sock.c return (str - buf);
str 900 net/bluetooth/sco.c char *str = buf;
str 905 net/bluetooth/sco.c str += sprintf(str, "%s %s %d\n",
str 912 net/bluetooth/sco.c return (str - buf);
str 554 net/core/dev.c str = get_options(str, ARRAY_SIZE(ints), ints);
str 555 net/core/dev.c if (!str || !*str)
str 570 net/core/dev.c return netdev_boot_setup_add(str, &map);
str 63 net/core/utils.c if (*str != '\0')
str 66 net/core/utils.c while (*str != '\0' && *str != '.' && *str != '\n')
str 69 net/core/utils.c val += *str - '0';
str 70 net/core/utils.c str++;
str 73 net/core/utils.c if (*str != '\0')
str 74 net/core/utils.c str++;
str 71 net/decnet/sysctl_net_decnet.c switch(*str) {
str 76 net/decnet/sysctl_net_decnet.c *str = 0;
str 80 net/decnet/sysctl_net_decnet.c str++;
str 92 net/decnet/sysctl_net_decnet.c while(*str && !ISNUM(*str)) str++;
str 94 net/decnet/sysctl_net_decnet.c if (*str == 0)
str 97 net/decnet/sysctl_net_decnet.c area = (*str++ - '0');
str 98 net/decnet/sysctl_net_decnet.c if (ISNUM(*str)) {
str 100 net/decnet/sysctl_net_decnet.c area += (*str++ - '0');
str 103 net/decnet/sysctl_net_decnet.c if (*str++ != '.')
str 106 net/decnet/sysctl_net_decnet.c if (!ISNUM(*str))
str 109 net/decnet/sysctl_net_decnet.c node = *str++ - '0';
str 110 net/decnet/sysctl_net_decnet.c if (ISNUM(*str)) {
str 112 net/decnet/sysctl_net_decnet.c node += (*str++ - '0');
str 114 net/decnet/sysctl_net_decnet.c if (ISNUM(*str)) {
str 116 net/decnet/sysctl_net_decnet.c node += (*str++ - '0');
str 118 net/decnet/sysctl_net_decnet.c if (ISNUM(*str)) {
str 120 net/decnet/sysctl_net_decnet.c node += (*str++ - '0');
str 126 net/decnet/sysctl_net_decnet.c if (INVALID_END_CHAR(*str))
str 3246 net/ipv4/route.c if (!str)
str 3248 net/ipv4/route.c rhash_entries = simple_strtoul(str, &str, 0);
str 2674 net/ipv4/tcp.c if (!str)
str 2676 net/ipv4/tcp.c thash_entries = simple_strtoul(str, &str, 0);
str 222 net/irda/irlan/irlan_filter.c #define MASK2STR(m,s) { .mask = m, .str = s }
str 228 net/irda/irlan/irlan_filter.c const char *str;
str 240 net/irda/irlan/irlan_filter.c for (p = filter_mask2str; p->str; p++) {
str 242 net/irda/irlan/irlan_filter.c seq_printf(seq, "%s ", p->str);
str 293 net/irda/parameters.c char str[33];
str 315 net/irda/parameters.c strncpy(str, buf+2, p.pl);
str 318 net/irda/parameters.c (__u8) str[0], (__u8) str[1]);
str 321 net/irda/parameters.c str[p.pl+1] = '\0';
str 323 net/irda/parameters.c p.pv.c = str; /* Handler will need to take a copy */
str 269 net/netlink/attr.c int len = strlen(str) + 1;
str 273 net/netlink/attr.c d = memcmp(nla_data(nla), str, len);
str 49 net/sunrpc/auth_gss/gss_generic_token.c memcpy((ptr), (char *) (str), (len)); \
str 965 net/sunrpc/cache.c while ((c=*str++) && len)
str 181 net/tipc/link.c link_print(l_ptr, DBG_OUTPUT, str);
str 3310 net/tipc/link.c tipc_printf(buf, str);
str 49 net/tipc/msg.c tipc_printf(buf, str);
str 1029 net/tipc/name_table.c tipc_printf(buf, str);
str 587 net/tipc/node.c tipc_printf(buf, "\n\n%s", str);
str 706 net/tipc/node.c sprintf(link_info.str, tipc_bclink_name);
str 722 net/tipc/node.c strcpy(link_info.str, n_ptr->links[i]->name);
str 75 scripts/genksyms/genksyms.h #define xstrdup(str) ({ char *__str = strdup(str); \
str 60 scripts/kallsyms.c return str[0] == '$' && strchr("atd", str[1])
str 61 scripts/kallsyms.c && (str[2] == '\0' || str[2] == '.');
str 66 scripts/kallsyms.c char str[500];
str 70 scripts/kallsyms.c rc = fscanf(in, "%llx %c %499s\n", &s->addr, &stype, str);
str 74 scripts/kallsyms.c fgets(str, 500, in);
str 79 scripts/kallsyms.c sym = str;
str 81 scripts/kallsyms.c if (symbol_prefix_char && str[0] == symbol_prefix_char)
str 109 scripts/kallsyms.c else if (str[0] == '$')
str 117 scripts/kallsyms.c s->len = strlen(str) + 1;
str 124 scripts/kallsyms.c strcpy((char *)s->sym + 1, str);
str 378 scripts/kallsyms.c if (str[i] == token[0] && str[i+1] == token[1])
str 379 scripts/kallsyms.c return &str[i];
str 397 scripts/kallsyms.c p2 = find_token(p1, len, str);
str 416 scripts/kallsyms.c p2 = find_token(p1, size, str);
str 52 scripts/kconfig/conf.c char *p = str;
str 58 scripts/kconfig/conf.c if (p != str)
str 59 scripts/kconfig/conf.c memmove(str, p, l + 1);
str 62 scripts/kconfig/conf.c p = str + l - 1;
str 400 scripts/kconfig/confdata.c const char *str;
str 464 scripts/kconfig/confdata.c str = menu_get_prompt(menu);
str 468 scripts/kconfig/confdata.c "#\n", str);
str 496 scripts/kconfig/confdata.c str = sym_get_string_value(sym);
str 499 scripts/kconfig/confdata.c l = strcspn(str, "\"\\");
str 501 scripts/kconfig/confdata.c fwrite(str, l, 1, out);
str 502 scripts/kconfig/confdata.c str += l;
str 504 scripts/kconfig/confdata.c if (!*str)
str 506 scripts/kconfig/confdata.c fprintf(out, "\\%c", *str++);
str 511 scripts/kconfig/confdata.c str = sym_get_string_value(sym);
str 512 scripts/kconfig/confdata.c if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
str 513 scripts/kconfig/confdata.c fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
str 517 scripts/kconfig/confdata.c str = sym_get_string_value(sym);
str 518 scripts/kconfig/confdata.c fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
str 672 scripts/kconfig/confdata.c const char *str;
str 733 scripts/kconfig/confdata.c str = sym_get_string_value(sym);
str 737 scripts/kconfig/confdata.c l = strcspn(str, "\"\\");
str 739 scripts/kconfig/confdata.c fwrite(str, l, 1, out);
str 740 scripts/kconfig/confdata.c fwrite(str, l, 1, out_h);
str 741 scripts/kconfig/confdata.c str += l;
str 743 scripts/kconfig/confdata.c if (!*str)
str 745 scripts/kconfig/confdata.c fprintf(out, "\\%c", *str);
str 746 scripts/kconfig/confdata.c fprintf(out_h, "\\%c", *str);
str 747 scripts/kconfig/confdata.c str++;
str 753 scripts/kconfig/confdata.c str = sym_get_string_value(sym);
str 754 scripts/kconfig/confdata.c if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
str 755 scripts/kconfig/confdata.c fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
str 756 scripts/kconfig/confdata.c fprintf(out_h, "#define CONFIG_%s 0x%s\n", sym->name, str);
str 760 scripts/kconfig/confdata.c str = sym_get_string_value(sym);
str 761 scripts/kconfig/confdata.c fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
str 762 scripts/kconfig/confdata.c fprintf(out_h, "#define CONFIG_%s %s\n", sym->name, str);
str 1090 scripts/kconfig/expr.c fwrite(str, strlen(str), 1, data);
str 1100 scripts/kconfig/expr.c str_append((struct gstr*)data, str);
str 166 scripts/kconfig/lxdialog/dialog.h char str[MAXITEMSTR]; /* promtp displayed */
str 561 scripts/kconfig/lxdialog/util.c vsnprintf(item_cur->node.str, sizeof(item_cur->node.str), fmt, ap);
str 570 scripts/kconfig/lxdialog/util.c avail = sizeof(item_cur->node.str) - strlen(item_cur->node.str);
str 573 scripts/kconfig/lxdialog/util.c vsnprintf(item_cur->node.str + strlen(item_cur->node.str),
str 575 scripts/kconfig/lxdialog/util.c item_cur->node.str[sizeof(item_cur->node.str) - 1] = '\0';
str 644 scripts/kconfig/lxdialog/util.c return item_cur->node.str;
str 45 scripts/kconfig/qconf.cc return QString::fromLocal8Bit(gettext(str));
str 50 scripts/kconfig/qconf.cc return QString::fromLocal8Bit(gettext(str.latin1()));
str 996 scripts/kconfig/qconf.cc QString str;
str 998 scripts/kconfig/qconf.cc str += "<big>Symbol: <b>";
str 999 scripts/kconfig/qconf.cc str += print_filter(sym->name);
str 1000 scripts/kconfig/qconf.cc str += "</b></big><br><br>value: ";
str 1001 scripts/kconfig/qconf.cc str += print_filter(sym_get_string_value(sym));
str 1002 scripts/kconfig/qconf.cc str += "<br>visibility: ";
str 1003 scripts/kconfig/qconf.cc str += sym->visible == yes ? "y" : sym->visible == mod ? "m" : "n";
str 1004 scripts/kconfig/qconf.cc str += "<br>";
str 1005 scripts/kconfig/qconf.cc str += debug_info(sym);
str 1007 scripts/kconfig/qconf.cc setText(str);
str 1125 scripts/kconfig/qconf.cc QString res = str;
str 1156 scripts/kconfig/qconf.cc QString str2 = print_filter(str);
str 1633 scripts/kconfig/qconf.cc static const QString str = _("Welcome to the qconf graphical kernel configuration tool for Linux.\n\n"
str 1645 scripts/kconfig/qconf.cc QMessageBox::information(this, "qconf", str);
str 1650 scripts/kconfig/qconf.cc static const QString str = _("qconf is Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>.\n\n"
str 1653 scripts/kconfig/qconf.cc QMessageBox::information(this, "qconf", str);
str 268 scripts/kconfig/qconf.h static QString print_filter(const QString &str);
str 269 scripts/kconfig/qconf.h static void expr_print_help(void *data, struct symbol *sym, const char *str);
str 160 scripts/kconfig/symbol.c char str[64];
str 183 scripts/kconfig/symbol.c sprintf(str, "%d", val2);
str 185 scripts/kconfig/symbol.c sprintf(str, "0x%x", val2);
str 186 scripts/kconfig/symbol.c sym->curr.val = strdup(str);
str 500 scripts/kconfig/symbol.c ch = *str++;
str 502 scripts/kconfig/symbol.c ch = *str++;
str 505 scripts/kconfig/symbol.c if (ch == '0' && *str != 0)
str 507 scripts/kconfig/symbol.c while ((ch = *str++)) {
str 513 scripts/kconfig/symbol.c if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
str 514 scripts/kconfig/symbol.c str += 2;
str 515 scripts/kconfig/symbol.c ch = *str++;
str 519 scripts/kconfig/symbol.c } while ((ch = *str++));
str 523 scripts/kconfig/symbol.c switch (str[0]) {
str 542 scripts/kconfig/symbol.c return sym_string_valid(sym, str);
str 544 scripts/kconfig/symbol.c if (!sym_string_valid(sym, str))
str 549 scripts/kconfig/symbol.c val = strtol(str, NULL, 10);
str 553 scripts/kconfig/symbol.c if (!sym_string_valid(sym, str))
str 558 scripts/kconfig/symbol.c val = strtol(str, NULL, 16);
str 563 scripts/kconfig/symbol.c switch (str[0]) {
str 574 scripts/kconfig/zconf.y while ((p = strchr(str, '"'))) {
str 575 scripts/kconfig/zconf.y len = p - str;
str 577 scripts/kconfig/zconf.y fprintf(out, "%.*s", len, str);
str 579 scripts/kconfig/zconf.y str = p + 1;
str 581 scripts/kconfig/zconf.y fputs(str, out);
str 43 scripts/mod/file2alias.c strcat(str, sep); \
str 45 scripts/mod/file2alias.c sprintf(str + strlen(str), \
str 51 scripts/mod/file2alias.c sprintf(str + strlen(str), "*"); \
str 57 scripts/mod/file2alias.c int len = strlen(str);
str 59 scripts/mod/file2alias.c if (str[len - 1] != '*')
str 60 scripts/mod/file2alias.c strcat(str + len, "*");
str 217 scripts/mod/modpost.c const char *str;
str 220 scripts/mod/modpost.c { .str = "EXPORT_SYMBOL", .export = export_plain },
str 221 scripts/mod/modpost.c { .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused },
str 222 scripts/mod/modpost.c { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl },
str 223 scripts/mod/modpost.c { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
str 224 scripts/mod/modpost.c { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
str 225 scripts/mod/modpost.c { .str = "(unknown)", .export = export_unknown },
str 231 scripts/mod/modpost.c return export_list[ex].str;
str 241 scripts/mod/modpost.c if (strcmp(export_list[i].str, s) == 0)
str 1028 scripts/mod/modpost.c return str[0] == '$' && strchr("atd", str[1])
str 1029 scripts/mod/modpost.c && (str[2] == '\0' || str[2] == '.');
str 651 scripts/unifdef.c const char *str;
str 751 scripts/unifdef.c for (op = ops->op; op->str != NULL; op++)
str 752 scripts/unifdef.c if (strncmp(cp, op->str, strlen(op->str)) == 0)
str 754 scripts/unifdef.c if (op->str == NULL)
str 756 scripts/unifdef.c cp += strlen(op->str);
str 757 scripts/unifdef.c debug("eval%d %s", ops - eval_ops, op->str);
str 915 scripts/unifdef.c cp = skipsym(str);
str 916 scripts/unifdef.c if (cp == str)
str 919 scripts/unifdef.c printf("%.*s\n", (int)(cp-str), str);
str 924 scripts/unifdef.c if (strlcmp(symname[symind], str, cp-str) == 0) {
str 268 security/device_cgroup.c strcpy(str, "*");
str 270 security/device_cgroup.c sprintf(str, "%u", m);
str 70 security/security.c strncpy(chosen_lsm, str, SECURITY_NAME_MAX);
str 31 security/selinux/exports.c return security_context_to_sid(str, strlen(str), sid);
str 107 security/selinux/hooks.c if (!strict_strtoul(str, 0, &enforcing))
str 120 security/selinux/hooks.c if (!strict_strtoul(str, 0, &enabled))
str 5262 security/selinux/hooks.c char *str = value;
str 5291 security/selinux/hooks.c if (size && str[1] && str[1] != '\n') {
str 5292 security/selinux/hooks.c if (str[size-1] == '\n') {
str 5293 security/selinux/hooks.c str[size-1] = 0;
str 61 security/selinux/selinuxfs.c if (!strict_strtoul(str, 0, &checkreqprot))
str 70 security/selinux/selinuxfs.c if (!strict_strtoul(str, 0, &compat_net))
str 31 security/selinux/ss/context.h char *str; /* string representation if context cannot be mapped. */
str 116 security/selinux/ss/context.h if (src->str) {
str 117 security/selinux/ss/context.h dst->str = kstrdup(src->str, GFP_ATOMIC);
str 118 security/selinux/ss/context.h if (!dst->str)
str 122 security/selinux/ss/context.h dst->str = NULL;
str 127 security/selinux/ss/context.h kfree(dst->str);
str 136 security/selinux/ss/context.h kfree(c->str);
str 137 security/selinux/ss/context.h c->str = NULL;
str 145 security/selinux/ss/context.h return (c1->len == c2->len && !strcmp(c1->str, c2->str));
str 395 security/selinux/ss/mls.c tmpstr = freestr = kstrdup(str, gfp_mask);
str 793 security/selinux/ss/services.c *scontext = kstrdup(context->str, GFP_ATOMIC);
str 997 security/selinux/ss/services.c char *scontext2, *str = NULL;
str 1024 security/selinux/ss/services.c str = kstrdup(scontext2, gfp_flags);
str 1025 security/selinux/ss/services.c if (!str) {
str 1036 security/selinux/ss/services.c context.str = str;
str 1038 security/selinux/ss/services.c str = NULL;
str 1046 security/selinux/ss/services.c kfree(str);
str 1524 security/selinux/ss/services.c if (c->str) {
str 1526 security/selinux/ss/services.c s = kstrdup(c->str, GFP_KERNEL);
str 1537 security/selinux/ss/services.c c->str);
str 1539 security/selinux/ss/services.c kfree(c->str);
str 1550 security/selinux/ss/services.c c->str, -rc);
str 1603 security/selinux/ss/services.c c->str = s;
str 1607 security/selinux/ss/services.c c->str);
str 193 security/selinux/ss/sidtab.c context->str);
str 61 sound/core/info.c if (!strcmp(*xstr, str))
str 65 sound/core/info.c if (!strncmp(str, "card", 4))
str 616 sound/core/info.c char str[8];
str 622 sound/core/info.c sprintf(str, "card%i", card->number);
str 623 sound/core/info.c if ((entry = snd_info_create_module_entry(card->module, str, NULL)) == NULL)
str 73 sound/core/info_oss.c char *str;
str 78 sound/core/info_oss.c str = snd_sndstat_strings[idx][dev];
str 79 sound/core/info_oss.c if (str) {
str 84 sound/core/info_oss.c snd_iprintf(buf, "%i: %s\n", idx, str);
str 937 sound/core/oss/mixer_oss.c char str[64];
str 944 sound/core/oss/mixer_oss.c sprintf(str, "%s Switch", ptr->name);
str 945 sound/core/oss/mixer_oss.c err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
str 949 sound/core/oss/mixer_oss.c sprintf(str, "%s Route", ptr->name);
str 950 sound/core/oss/mixer_oss.c err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
str 954 sound/core/oss/mixer_oss.c sprintf(str, "%s Volume", ptr->name);
str 955 sound/core/oss/mixer_oss.c err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
str 959 sound/core/oss/mixer_oss.c sprintf(str, "%s Playback Switch", ptr->name);
str 960 sound/core/oss/mixer_oss.c err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
str 964 sound/core/oss/mixer_oss.c sprintf(str, "%s Playback Route", ptr->name);
str 965 sound/core/oss/mixer_oss.c err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
str 969 sound/core/oss/mixer_oss.c sprintf(str, "%s Playback Volume", ptr->name);
str 970 sound/core/oss/mixer_oss.c err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
str 974 sound/core/oss/mixer_oss.c sprintf(str, "%s Capture Switch", ptr->name);
str 975 sound/core/oss/mixer_oss.c err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
str 979 sound/core/oss/mixer_oss.c sprintf(str, "%s Capture Route", ptr->name);
str 980 sound/core/oss/mixer_oss.c err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
str 984 sound/core/oss/mixer_oss.c sprintf(str, "%s Capture Volume", ptr->name);
str 985 sound/core/oss/mixer_oss.c err = snd_mixer_oss_build_test(mixer, slot, str, ptr->index,
str 1004 sound/core/oss/mixer_oss.c char str[64];
str 1028 sound/core/oss/mixer_oss.c strcpy(str, ptr->name);
str 1029 sound/core/oss/mixer_oss.c if (!strcmp(str, "Master"))
str 1030 sound/core/oss/mixer_oss.c strcpy(str, "Mix");
str 1031 sound/core/oss/mixer_oss.c if (!strcmp(str, "Master Mono"))
str 1032 sound/core/oss/mixer_oss.c strcpy(str, "Mix Mono");
str 1034 sound/core/oss/mixer_oss.c if (!strcmp(uinfo->value.enumerated.name, str)) {
str 1043 sound/core/oss/mixer_oss.c if (!strcmp(uinfo->value.enumerated.name, str)) {
str 1146 sound/core/oss/mixer_oss.c char line[128], str[32], idxstr[16], *cptr;
str 1152 sound/core/oss/mixer_oss.c cptr = snd_info_get_str(str, line, sizeof(str));
str 1154 sound/core/oss/mixer_oss.c if (oss_mixer_names[ch] && strcmp(oss_mixer_names[ch], str) == 0)
str 1157 sound/core/oss/mixer_oss.c snd_printk(KERN_ERR "mixer_oss: invalid OSS volume '%s'\n", str);
str 1160 sound/core/oss/mixer_oss.c cptr = snd_info_get_str(str, cptr, sizeof(str));
str 1161 sound/core/oss/mixer_oss.c if (! *str) {
str 1177 sound/core/oss/mixer_oss.c slot->assigned->index == idx && ! strcmp(slot->assigned->name, str))
str 1186 sound/core/oss/mixer_oss.c tbl->name = kstrdup(str, GFP_KERNEL);
str 2825 sound/core/oss/pcm_oss.c char line[128], str[32], task_name[32], *ptr;
str 2844 sound/core/oss/pcm_oss.c ptr = snd_info_get_str(str, ptr, sizeof(str));
str 2845 sound/core/oss/pcm_oss.c template.periods = simple_strtoul(str, NULL, 10);
str 2846 sound/core/oss/pcm_oss.c ptr = snd_info_get_str(str, ptr, sizeof(str));
str 2847 sound/core/oss/pcm_oss.c template.period_size = simple_strtoul(str, NULL, 10);
str 2854 sound/core/oss/pcm_oss.c ptr = snd_info_get_str(str, ptr, sizeof(str));
str 2855 sound/core/oss/pcm_oss.c if (!strcmp(str, "disable")) {
str 2857 sound/core/oss/pcm_oss.c } else if (!strcmp(str, "direct")) {
str 2859 sound/core/oss/pcm_oss.c } else if (!strcmp(str, "block")) {
str 2861 sound/core/oss/pcm_oss.c } else if (!strcmp(str, "non-block")) {
str 2863 sound/core/oss/pcm_oss.c } else if (!strcmp(str, "partial-frag")) {
str 2865 sound/core/oss/pcm_oss.c } else if (!strcmp(str, "no-silence")) {
str 2867 sound/core/oss/pcm_oss.c } else if (!strcmp(str, "buggy-ptr")) {
str 2870 sound/core/oss/pcm_oss.c } while (*str);
str 930 sound/core/pcm.c const char *str;
str 940 sound/core/pcm.c str = "none";
str 942 sound/core/pcm.c str = strs[pcm->dev_class];
str 943 sound/core/pcm.c return snprintf(buf, PAGE_SIZE, "%s\n", str);
str 954 sound/core/pcm.c char str[16];
str 972 sound/core/pcm.c sprintf(str, "pcmC%iD%ip", pcm->card->number, pcm->device);
str 976 sound/core/pcm.c sprintf(str, "pcmC%iD%ic", pcm->card->number, pcm->device);
str 990 sound/core/pcm.c pcm, str, dev);
str 164 sound/core/pcm_memory.c char line[64], str[64];
str 173 sound/core/pcm_memory.c snd_info_get_str(str, line, sizeof(str));
str 174 sound/core/pcm_memory.c size = simple_strtoul(str, NULL, 10) * 1024;
str 2070 sound/core/pcm_native.c struct snd_pcm_str *str;
str 2087 sound/core/pcm_native.c str = substream->pstr;
str 507 sound/core/seq/oss/seq_oss_init.c static char *str[] = {
str 510 sound/core/seq/oss/seq_oss_init.c return str[val & SNDRV_SEQ_OSS_FILE_ACMODE];
str 269 sound/core/seq/seq_timer.c char str[32];
str 277 sound/core/seq/seq_timer.c sprintf(str, "sequencer queue %i", q->queue);
str 282 sound/core/seq/seq_timer.c err = snd_timer_open(&t, str, &tmr->alsa_id, q->queue);
str 292 sound/core/seq/seq_timer.c err = snd_timer_open(&t, str, &tid, q->queue);
str 84 sound/core/sound.c char *str;
str 87 sound/core/sound.c case SNDRV_MINOR_SEQUENCER: str = "snd-seq"; break;
str 88 sound/core/sound.c case SNDRV_MINOR_TIMER: str = "snd-timer"; break;
str 91 sound/core/sound.c request_module(str);
str 1505 sound/core/timer.c char str[32];
str 1518 sound/core/timer.c sprintf(str, "application %i", current->pid);
str 1521 sound/core/timer.c err = snd_timer_open(&tu->timeri, str, &tselect.id, current->pid);
str 126 sound/drivers/opl3/opl3_midi.c char *str = "x.24";
str 130 sound/drivers/opl3/opl3_midi.c printk("%c", *(str + opl3->voices[i].state + 1));
str 1697 sound/isa/es18xx.c char str[16];
str 1702 sound/isa/es18xx.c sprintf(str, "ES%x", chip->version);
str 1704 sound/isa/es18xx.c err = snd_pcm_new(chip->card, str, device, 2, 1, &pcm);
str 1706 sound/isa/es18xx.c err = snd_pcm_new(chip->card, str, device, 1, 1, &pcm);
str 655 sound/isa/gus/interwave.c char *str;
str 751 sound/isa/gus/interwave.c str = "AMD InterWave";
str 753 sound/isa/gus/interwave.c str = "Dynasonic 3-D";
str 755 sound/isa/gus/interwave.c str = "InterWave STB";
str 757 sound/isa/gus/interwave.c strcpy(card->driver, str);
str 758 sound/isa/gus/interwave.c strcpy(card->shortname, str);
str 760 sound/isa/gus/interwave.c str,
str 229 sound/isa/opl3sa2.c char str[2];
str 256 sound/isa/opl3sa2.c str[0] = chip->version + '0';
str 257 sound/isa/opl3sa2.c str[1] = 0;
str 258 sound/isa/opl3sa2.c strcat(card->shortname, str);
str 108 sound/isa/sb/sb_common.c char *str;
str 136 sound/isa/sb/sb_common.c str = "1.0";
str 141 sound/isa/sb/sb_common.c str = "2.01+";
str 144 sound/isa/sb/sb_common.c str = "2.0";
str 149 sound/isa/sb/sb_common.c str = "Pro";
str 153 sound/isa/sb/sb_common.c str = "16";
str 162 sound/isa/sb/sb_common.c str = "16 (ALS-100)";
str 165 sound/isa/sb/sb_common.c str = "16 (ALS-4000)";
str 168 sound/isa/sb/sb_common.c str = "(DT019X/ALS007)";
str 171 sound/isa/sb/sb_common.c str = "16 (CS5530)";
str 176 sound/isa/sb/sb_common.c sprintf(chip->name, "Sound Blaster %s", str);
str 3055 sound/oss/ad1848.c str = get_options(str, ARRAY_SIZE(ints), ints);
str 1360 sound/oss/aedsp16.c str = get_options(str, ARRAY_SIZE(ints), ints);
str 1292 sound/oss/au1550_ac97.c const char *str;
str 1361 sound/oss/au1550_ac97.c pr_debug("ioctl %s, arg=0x%lxn", ioctl_str[count].str, arg);
str 1414 sound/oss/dmasound/dmasound_core.c str = get_options(str, ARRAY_SIZE(ints), ints);
str 1805 sound/oss/mpu401.c str = get_options(str, ARRAY_SIZE(ints), ints);
str 1241 sound/oss/opl3.c str = get_options(str, ARRAY_SIZE(ints), ints);
str 441 sound/oss/pas2_card.c str = get_options(str, ARRAY_SIZE(ints), ints);
str 1253 sound/oss/pss.c str = get_options(str, ARRAY_SIZE(ints), ints);
str 1467 sound/oss/sscape.c str = get_options(str, ARRAY_SIZE(ints), ints);
str 508 sound/oss/trix.c str = get_options(str, ARRAY_SIZE(ints), ints);
str 471 sound/oss/uart401.c str = get_options(str, ARRAY_SIZE(ints), ints);
str 352 sound/oss/uart6850.c str = get_options(str, ARRAY_SIZE(ints), ints);
str 2015 sound/oss/waveartist.c str = get_options(str, ARRAY_SIZE(ints), ints);
str 82 sound/pci/trident/trident.c const char *str;
str 108 sound/pci/trident/trident.c str = "TRID4DWAVEDX";
str 111 sound/pci/trident/trident.c str = "TRID4DWAVENX";
str 114 sound/pci/trident/trident.c str = "SI7018";
str 117 sound/pci/trident/trident.c str = "Unknown";
str 119 sound/pci/trident/trident.c strcpy(card->driver, str);
str 179 sound/pci/ymfpci/ymfpci.c const char *str, *model;
str 195 sound/pci/ymfpci/ymfpci.c case 0x0004: str = "YMF724"; model = "DS-1"; break;
str 196 sound/pci/ymfpci/ymfpci.c case 0x000d: str = "YMF724F"; model = "DS-1"; break;
str 197 sound/pci/ymfpci/ymfpci.c case 0x000a: str = "YMF740"; model = "DS-1L"; break;
str 198 sound/pci/ymfpci/ymfpci.c case 0x000c: str = "YMF740C"; model = "DS-1L"; break;
str 199 sound/pci/ymfpci/ymfpci.c case 0x0010: str = "YMF744"; model = "DS-1S"; break;
str 200 sound/pci/ymfpci/ymfpci.c case 0x0012: str = "YMF754"; model = "DS-1E"; break;
str 201 sound/pci/ymfpci/ymfpci.c default: model = str = "???"; break;
str 275 sound/pci/ymfpci/ymfpci.c strcpy(card->driver, str);
str 276 sound/pci/ymfpci/ymfpci.c sprintf(card->shortname, "Yamaha %s (%s)", model, str);
str 29 sound/soc/fsl/fsl_ssi.h __be32 str; /* 0x.0030 - SSI Test Register */
str 140 usr/gen_init_cpio.c if (5 != sscanf(line, "%" str(PATH_MAX) "s %" str(PATH_MAX) "s %o %d %d", name, target, &mode, &uid, &gid)) {
str 210 usr/gen_init_cpio.c if (4 != sscanf(line, "%" str(PATH_MAX) "s %o %d %d", name, &mode, &uid, &gid)) {
str 280 usr/gen_init_cpio.c if (7 != sscanf(line, "%" str(PATH_MAX) "s %o %d %d %c %u %u",
str 385 usr/gen_init_cpio.c if (5 > sscanf(line, "%" str(PATH_MAX) "s %" str(PATH_MAX)
str 406 usr/gen_init_cpio.c if (sscanf(line + end, "%" str(PATH_MAX) "s %n",