lib/libintl/gettext.c

1000

db->mohandle.mo.mo_magic)

lib/libintl/gettext.c

1023

if (db->mohandle.mo.mo_plural) {

lib/libintl/gettext.c

1025

_gettext_calculate_plural(db->mohandle.mo.mo_plural, n);

lib/libintl/gettext.c

1026

if (plural_index >= db->mohandle.mo.mo_nplurals)

lib/libintl/gettext.c

1037

if (db->mohandle.mo.mo_plural)

lib/libintl/gettext.c

457

mohandle->mo.mo_sysdep_segs[str->segs[i].ref].len;

lib/libintl/gettext.c

471

memcpy(dst, mohandle->mo.mo_sysdep_segs[str->segs[i].ref].str,

lib/libintl/gettext.c

472

mohandle->mo.mo_sysdep_segs[str->segs[i].ref].len);

lib/libintl/gettext.c

473

dst += mohandle->mo.mo_sysdep_segs[str->segs[i].ref].len;

lib/libintl/gettext.c

496

setup_sysdep_stuffs(struct mo *mo, struct mohandle *mohandle, char *base)

lib/libintl/gettext.c

505

magic = mo->mo_magic;

lib/libintl/gettext.c

507

mohandle->mo.mo_sysdep_nsegs = flip(mo->mo_sysdep_nsegs, magic);

lib/libintl/gettext.c

508

mohandle->mo.mo_sysdep_nstring = flip(mo->mo_sysdep_nstring, magic);

lib/libintl/gettext.c

510

if (mohandle->mo.mo_sysdep_nstring == 0)

lib/libintl/gettext.c

514

if (mohandle->mo.mo_hsize <= 2 ||

lib/libintl/gettext.c

515

mohandle->mo.mo_hsize <

lib/libintl/gettext.c

516

(mohandle->mo.mo_nstring + mohandle->mo.mo_sysdep_nstring))

lib/libintl/gettext.c

520

l = sizeof(struct mosysdepsegs_h) * mohandle->mo.mo_sysdep_nsegs;

lib/libintl/gettext.c

521

mohandle->mo.mo_sysdep_segs = (struct mosysdepsegs_h *)malloc(l);

lib/libintl/gettext.c

522

if (!mohandle->mo.mo_sysdep_segs)

lib/libintl/gettext.c

525

stable = (struct moentry *)(base + flip(mo->mo_sysdep_segoff, magic));

lib/libintl/gettext.c

526

for (i=0; i<mohandle->mo.mo_sysdep_nsegs; i++) {

lib/libintl/gettext.c

528

mohandle->mo.mo_sysdep_segs[i].str =

lib/libintl/gettext.c

531

&mohandle->mo.mo_sysdep_segs[i].len);

lib/libintl/gettext.c

535

mohandle->mo.mo_sysdep_otable =

lib/libintl/gettext.c

536

(struct mosysdepstr_h **)calloc(mohandle->mo.mo_sysdep_nstring,

lib/libintl/gettext.c

538

if (!mohandle->mo.mo_sysdep_otable)

lib/libintl/gettext.c

541

ofstable = (uint32_t *)(base + flip(mo->mo_sysdep_otable, magic));

lib/libintl/gettext.c

542

if (get_sysdep_string_table(mohandle->mo.mo_sysdep_otable, ofstable,

lib/libintl/gettext.c

543

mohandle->mo.mo_sysdep_nstring, magic,

lib/libintl/gettext.c

546

mohandle->mo.mo_sysdep_ttable =

lib/libintl/gettext.c

547

(struct mosysdepstr_h **)calloc(mohandle->mo.mo_sysdep_nstring,

lib/libintl/gettext.c

549

if (!mohandle->mo.mo_sysdep_ttable)

lib/libintl/gettext.c

552

ofstable = (uint32_t *)(base + flip(mo->mo_sysdep_ttable, magic));

lib/libintl/gettext.c

553

if (get_sysdep_string_table(mohandle->mo.mo_sysdep_ttable, ofstable,

lib/libintl/gettext.c

554

mohandle->mo.mo_sysdep_nstring, magic,

lib/libintl/gettext.c

559

for (i=0; i<mohandle->mo.mo_sysdep_nstring; i++) {

lib/libintl/gettext.c

560

if (expand_sysdep(mohandle, mohandle->mo.mo_sysdep_otable[i]))

lib/libintl/gettext.c

562

insert_to_hash(mohandle->mo.mo_htable,

lib/libintl/gettext.c

563

mohandle->mo.mo_hsize,

lib/libintl/gettext.c

564

mohandle->mo.mo_sysdep_otable[i]->expanded,

lib/libintl/gettext.c

581

struct mo *mo;

lib/libintl/gettext.c

588

mohandle->mo.mo_magic)

lib/libintl/gettext.c

634

mo = (struct mo *)mohandle->addr;

lib/libintl/gettext.c

637

mohandle->mo.mo_magic = mo->mo_magic;

lib/libintl/gettext.c

638

mohandle->mo.mo_revision = flip(mo->mo_revision, magic);

lib/libintl/gettext.c

639

mohandle->mo.mo_nstring = flip(mo->mo_nstring, magic);

lib/libintl/gettext.c

640

mohandle->mo.mo_hsize = flip(mo->mo_hsize, magic);

lib/libintl/gettext.c

641

mohandle->mo.mo_flags = flags;

lib/libintl/gettext.c

645

otable = (struct moentry *)(base + flip(mo->mo_otable, magic));

lib/libintl/gettext.c

647

ttable = (struct moentry *)(base + flip(mo->mo_ttable, magic));

lib/libintl/gettext.c

649

!validate(&otable[mohandle->mo.mo_nstring], mohandle)) {

lib/libintl/gettext.c

654

!validate(&ttable[mohandle->mo.mo_nstring], mohandle)) {

lib/libintl/gettext.c

660

l = sizeof(struct moentry_h) * mohandle->mo.mo_nstring;

lib/libintl/gettext.c

661

mohandle->mo.mo_otable = (struct moentry_h *)malloc(l);

lib/libintl/gettext.c

662

if (!mohandle->mo.mo_otable) {

lib/libintl/gettext.c

666

mohandle->mo.mo_ttable = (struct moentry_h *)malloc(l);

lib/libintl/gettext.c

667

if (!mohandle->mo.mo_ttable) {

lib/libintl/gettext.c

671

p = mohandle->mo.mo_otable;

lib/libintl/gettext.c

672

for (i = 0; i < mohandle->mo.mo_nstring; i++) {

lib/libintl/gettext.c

682

p = mohandle->mo.mo_ttable;

lib/libintl/gettext.c

683

for (i = 0; i < mohandle->mo.mo_nstring; i++) {

lib/libintl/gettext.c

694

if (mohandle->mo.mo_hsize > 2) {

lib/libintl/gettext.c

695

l = sizeof(uint32_t) * mohandle->mo.mo_hsize;

lib/libintl/gettext.c

696

mohandle->mo.mo_htable = (uint32_t *)malloc(l);

lib/libintl/gettext.c

697

if (!mohandle->mo.mo_htable) {

lib/libintl/gettext.c

702

htable = (const uint32_t *)(base+flip(mo->mo_hoffset, magic));

lib/libintl/gettext.c

703

for (i=0; i < mohandle->mo.mo_hsize; i++) {

lib/libintl/gettext.c

704

mohandle->mo.mo_htable[i] = flip(htable[i], magic);

lib/libintl/gettext.c

705

if (mohandle->mo.mo_htable[i] >=

lib/libintl/gettext.c

706

mohandle->mo.mo_nstring+1) {

lib/libintl/gettext.c

714

mohandle->mo.mo_header = lookup("", db, &headerlen);

lib/libintl/gettext.c

715

if (mohandle->mo.mo_header)

lib/libintl/gettext.c

716

value = strstr(mohandle->mo.mo_header, "charset=");

lib/libintl/gettext.c

720

mohandle->mo.mo_charset = strdup(value + 8);

lib/libintl/gettext.c

721

if (!mohandle->mo.mo_charset)

lib/libintl/gettext.c

723

char *newline = strchr(mohandle->mo.mo_charset, '\n');

lib/libintl/gettext.c

727

if (!mohandle->mo.mo_header ||

lib/libintl/gettext.c

728

_gettext_parse_plural(&mohandle->mo.mo_plural,

lib/libintl/gettext.c

729

&mohandle->mo.mo_nplurals,

lib/libintl/gettext.c

730

mohandle->mo.mo_header, headerlen))

lib/libintl/gettext.c

731

mohandle->mo.mo_plural = NULL;

lib/libintl/gettext.c

742

if ((mohandle->mo.mo_flags & MO_F_SYSDEP) != 0) {

lib/libintl/gettext.c

743

if (setup_sysdep_stuffs(mo, mohandle, base)) {

lib/libintl/gettext.c

780

free(mohandle->mo.mo_otable);

lib/libintl/gettext.c

781

free(mohandle->mo.mo_ttable);

lib/libintl/gettext.c

782

free(mohandle->mo.mo_charset);

lib/libintl/gettext.c

783

free(mohandle->mo.mo_htable);

lib/libintl/gettext.c

784

free(mohandle->mo.mo_sysdep_segs);

lib/libintl/gettext.c

785

free_sysdep_table(mohandle->mo.mo_sysdep_otable,

lib/libintl/gettext.c

786

mohandle->mo.mo_sysdep_nstring);

lib/libintl/gettext.c

787

free_sysdep_table(mohandle->mo.mo_sysdep_ttable,

lib/libintl/gettext.c

788

mohandle->mo.mo_sysdep_nstring);

lib/libintl/gettext.c

789

_gettext_free_plural(mohandle->mo.mo_plural);

lib/libintl/gettext.c

790

memset(&mohandle->mo, 0, sizeof(mohandle->mo));

lib/libintl/gettext.c

803

if (mohandle->mo.mo_hsize <= 2 || mohandle->mo.mo_htable == NULL)

lib/libintl/gettext.c

807

step = calc_collision_step(hashval, mohandle->mo.mo_hsize);

lib/libintl/gettext.c

808

idx = hashval % mohandle->mo.mo_hsize;

lib/libintl/gettext.c

811

strno = mohandle->mo.mo_htable[idx];

lib/libintl/gettext.c

819

if (len <= mohandle->mo.mo_otable[strno].len &&

lib/libintl/gettext.c

820

!strcmp(msgid, mohandle->mo.mo_otable[strno].off)) {

lib/libintl/gettext.c

824

mohandle->mo.mo_ttable[strno].len;

lib/libintl/gettext.c

825

return mohandle->mo.mo_ttable[strno].off;

lib/libintl/gettext.c

830

sysdep_otable = mohandle->mo.mo_sysdep_otable[strno];

lib/libintl/gettext.c

831

sysdep_ttable = mohandle->mo.mo_sysdep_ttable[strno];

lib/libintl/gettext.c

843

idx = calc_next_index(idx, mohandle->mo.mo_hsize, step);

lib/libintl/gettext.c

856

bottom = mohandle->mo.mo_nstring;

lib/libintl/gettext.c

866

if ((size_t)middle >= mohandle->mo.mo_nstring)

lib/libintl/gettext.c

869

n = strcmp(msgid, mohandle->mo.mo_otable[middle].off);

lib/libintl/gettext.c

872

*rlen = mohandle->mo.mo_ttable[middle].len;

lib/libintl/gettext.c

873

return (const char *)mohandle->mo.mo_ttable[middle].off;

lib/libintl/gettext_iconv.c

113

const char *fromcode = db->mohandle.mo.mo_charset;

lib/libintl/libintl_local.h

130

struct mo_h mo; /* endian-flipped mo file header */

lib/libintl/textdomain.c

103

p->mohandle.mo.mo_magic = 0; /* invalidate current mapping */

sbin/newfs/newfs.c

265

mntoptparse_t mo;

sbin/newfs/newfs.c

389

mo = getmntopts(optarg, mopts, &mntflags, 0);

sbin/newfs/newfs.c

390

if (mo == NULL)

sbin/newfs/newfs.c

392

freemntopts(mo);

sys/dev/pci/cxgb/cxgb_t3_cpl.h

1492

__be32 mo;

sys/dev/pci/cxgb/cxgb_vsc7323.c

106

ret = mo->read(adap, ELMR_MDIO_ADDR, 0, ELMR_DATA_LO, vals);

sys/dev/pci/cxgb/cxgb_vsc7323.c

108

ret = mo->read(adap, ELMR_MDIO_ADDR, 0, ELMR_DATA_HI,

sys/dev/pci/cxgb/cxgb_vsc7323.c

60

const struct mdio_ops *mo = adapter_info(adap)->mdio_ops;

sys/dev/pci/cxgb/cxgb_vsc7323.c

63

ret = mo->write(adap, ELMR_MDIO_ADDR, 0, ELMR_ADDR, start);

sys/dev/pci/cxgb/cxgb_vsc7323.c

65

ret = mo->write(adap, ELMR_MDIO_ADDR, 0, ELMR_DATA_LO,

sys/dev/pci/cxgb/cxgb_vsc7323.c

68

ret = mo->write(adap, ELMR_MDIO_ADDR, 0, ELMR_DATA_HI,

sys/dev/pci/cxgb/cxgb_vsc7323.c

84

const struct mdio_ops *mo = adapter_info(adap)->mdio_ops;

sys/dev/pci/cxgb/cxgb_vsc7323.c

88

ret = mo->write(adap, ELMR_MDIO_ADDR, 0, ELMR_ADDR, start);

sys/dev/pci/cxgb/cxgb_vsc7323.c

93

ret = mo->read(adap, ELMR_MDIO_ADDR, 0, ELMR_STAT, &v);

sys/dev/sbus/tcx.c

649

struct mmo *mo, *mo_end;

sys/dev/sbus/tcx.c

683

mo = mmo;

sys/dev/sbus/tcx.c

686

for (; mo < mo_end; mo++) {

sys/dev/sbus/tcx.c

687

if ((u_int)off < mo->mo_uaddr)

sys/dev/sbus/tcx.c

690

u = off - mo->mo_uaddr;

sys/dev/sbus/tcx.c

691

sz = mo->mo_size;

sys/dev/sbus/tcx.c

699

if (mo->mo_uaddr == TCX_USER_RAM24 ||

sys/dev/sbus/tcx.c

700

mo->mo_uaddr == TCX_USER_RDFB32) {

sys/dev/sbus/tcx.c

711

sz = rr[mo->mo_bank].oa_size;

sys/dev/sbus/tcx.c

715

BUS_ADDR(rr[mo->mo_bank].oa_space,

sys/dev/sbus/tcx.c

716

rr[mo->mo_bank].oa_base),

sys/dev/scsipi/scsipi_base.c

1835

struct scsipi_max_openings mo;

sys/dev/scsipi/scsipi_base.c

1843

mo.mo_target = periph->periph_target;

sys/dev/scsipi/scsipi_base.c

1844

mo.mo_lun = periph->periph_lun;

sys/dev/scsipi/scsipi_base.c

1846

mo.mo_openings = periph->periph_active - 1;

sys/dev/scsipi/scsipi_base.c

1848

mo.mo_openings = periph->periph_openings - 1;

sys/dev/scsipi/scsipi_base.c

1850

if (mo.mo_openings < 0) {

sys/dev/scsipi/scsipi_base.c

1856

if (mo.mo_openings == 0) {

sys/dev/scsipi/scsipi_base.c

1859

mo.mo_openings = 1;

sys/dev/scsipi/scsipi_base.c

1861

scsipi_async_event(chan, ASYNC_EVENT_MAX_OPENINGS, &mo);

sys/dev/scsipi/scsipi_base.c

2535

struct scsipi_max_openings *mo)

sys/dev/scsipi/scsipi_base.c

2540

if (mo->mo_lun == -1) {

sys/dev/scsipi/scsipi_base.c

2547

minlun = maxlun = mo->mo_lun;

sys/dev/scsipi/scsipi_base.c

2551

periph = scsipi_lookup_periph_locked(chan, mo->mo_target, minlun);

sys/dev/scsipi/scsipi_base.c

2555

if (mo->mo_openings < periph->periph_openings)

sys/dev/scsipi/scsipi_base.c

2556

periph->periph_openings = mo->mo_openings;

sys/dev/scsipi/scsipi_base.c

2557

else if (mo->mo_openings > periph->periph_openings &&

sys/dev/scsipi/scsipi_base.c

2559

periph->periph_openings = mo->mo_openings;

sys/dev/sun/cgsix.c

1025

struct mmo *mo;

sys/dev/sun/cgsix.c

1051

for (mo = mmo; mo < &mmo[NMMO]; mo++) {

sys/dev/sun/cgsix.c

1052

if ((u_long)off < mo->mo_uaddr)

sys/dev/sun/cgsix.c

1054

u = off - mo->mo_uaddr;

sys/dev/sun/cgsix.c

1055

if (mo->mo_size == 0) {

sys/dev/sun/cgsix.c

1060

sz = mo->mo_size;

sys/dev/sun/cgsix.c

1064

sc->sc_paddr, u+mo->mo_physoff,

sys/kern/kern_mutex_obj.c

101

struct kmutexobj *mo = (struct kmutexobj *)lock;

sys/kern/kern_mutex_obj.c

103

KASSERTMSG(mo->mo_magic == MUTEX_OBJ_MAGIC,

sys/kern/kern_mutex_obj.c

105

__func__, mo, mo->mo_magic, MUTEX_OBJ_MAGIC);

sys/kern/kern_mutex_obj.c

106

KASSERTMSG(mo->mo_refcnt > 0,

sys/kern/kern_mutex_obj.c

108

__func__, mo, mo->mo_refcnt);

sys/kern/kern_mutex_obj.c

110

atomic_inc_uint(&mo->mo_refcnt);

sys/kern/kern_mutex_obj.c

122

struct kmutexobj *mo = (struct kmutexobj *)lock;

sys/kern/kern_mutex_obj.c

124

KASSERTMSG(mo->mo_magic == MUTEX_OBJ_MAGIC,

sys/kern/kern_mutex_obj.c

126

__func__, mo, mo->mo_magic, MUTEX_OBJ_MAGIC);

sys/kern/kern_mutex_obj.c

127

KASSERTMSG(mo->mo_refcnt > 0,

sys/kern/kern_mutex_obj.c

129

__func__, mo, mo->mo_refcnt);

sys/kern/kern_mutex_obj.c

132

if (atomic_dec_uint_nv(&mo->mo_refcnt) > 0) {

sys/kern/kern_mutex_obj.c

136

mutex_destroy(&mo->mo_lock);

sys/kern/kern_mutex_obj.c

137

kmem_intr_free(mo, sizeof(*mo));

sys/kern/kern_mutex_obj.c

149

struct kmutexobj *mo = (struct kmutexobj *)lock;

sys/kern/kern_mutex_obj.c

151

return mo->mo_refcnt;

sys/kern/kern_mutex_obj.c

58

struct kmutexobj *mo;

sys/kern/kern_mutex_obj.c

60

mo = kmem_intr_alloc(sizeof(*mo), KM_SLEEP);

sys/kern/kern_mutex_obj.c

61

KASSERT(ALIGNED_POINTER(mo, coherency_unit));

sys/kern/kern_mutex_obj.c

62

_mutex_init(&mo->mo_lock, type, ipl,

sys/kern/kern_mutex_obj.c

64

mo->mo_magic = MUTEX_OBJ_MAGIC;

sys/kern/kern_mutex_obj.c

65

mo->mo_refcnt = 1;

sys/kern/kern_mutex_obj.c

67

return (kmutex_t *)mo;

sys/kern/kern_mutex_obj.c

78

struct kmutexobj *mo;

sys/kern/kern_mutex_obj.c

80

mo = kmem_intr_alloc(sizeof(*mo), KM_NOSLEEP);

sys/kern/kern_mutex_obj.c

81

KASSERT(ALIGNED_POINTER(mo, coherency_unit));

sys/kern/kern_mutex_obj.c

82

if (__predict_true(mo != NULL)) {

sys/kern/kern_mutex_obj.c

83

_mutex_init(&mo->mo_lock, type, ipl,

sys/kern/kern_mutex_obj.c

85

mo->mo_magic = MUTEX_OBJ_MAGIC;

sys/kern/kern_mutex_obj.c

86

mo->mo_refcnt = 1;

sys/kern/kern_mutex_obj.c

89

return (kmutex_t *)mo;

sys/kern/uipc_mbuf.c

2173

mowner_init_owner(struct mowner *mo, const char *name, const char *descr)

sys/kern/uipc_mbuf.c

2175

memset(mo, 0, sizeof(*mo));

sys/kern/uipc_mbuf.c

2176

strlcpy(mo->mo_name, name, sizeof(mo->mo_name));

sys/kern/uipc_mbuf.c

2177

strlcpy(mo->mo_descr, descr, sizeof(mo->mo_descr));

sys/kern/uipc_mbuf.c

2181

mowner_attach(struct mowner *mo)

sys/kern/uipc_mbuf.c

2184

KASSERT(mo->mo_counters == NULL);

sys/kern/uipc_mbuf.c

2185

mo->mo_counters = percpu_alloc(sizeof(struct mowner_counter));

sys/kern/uipc_mbuf.c

2188

LIST_INSERT_HEAD(&mowners, mo, mo_link);

sys/kern/uipc_mbuf.c

2192

mowner_detach(struct mowner *mo)

sys/kern/uipc_mbuf.c

2195

KASSERT(mo->mo_counters != NULL);

sys/kern/uipc_mbuf.c

2198

LIST_REMOVE(mo, mo_link);

sys/kern/uipc_mbuf.c

2200

percpu_free(mo->mo_counters, sizeof(struct mowner_counter));

sys/kern/uipc_mbuf.c

2201

mo->mo_counters = NULL;

sys/kern/uipc_mbuf.c

2208

struct mowner *mo;

sys/kern/uipc_mbuf.c

2211

m->m_owner = mo = &unknown_mowners[type];

sys/kern/uipc_mbuf.c

2213

mc = percpu_getref(mo->mo_counters);

sys/kern/uipc_mbuf.c

2215

percpu_putref(mo->mo_counters);

sys/kern/uipc_mbuf.c

2222

struct mowner *mo = m->m_owner;

sys/kern/uipc_mbuf.c

2227

mc = percpu_getref(mo->mo_counters);

sys/kern/uipc_mbuf.c

2232

percpu_putref(mo->mo_counters);

sys/kern/uipc_mbuf.c

2239

struct mowner *mo = m->m_owner;

sys/kern/uipc_mbuf.c

2244

mc = percpu_getref(mo->mo_counters);

sys/kern/uipc_mbuf.c

2251

percpu_putref(mo->mo_counters);

sys/kern/uipc_mbuf.c

2258

mowner_claim(struct mbuf *m, struct mowner *mo)

sys/kern/uipc_mbuf.c

2265

mc = percpu_getref(mo->mo_counters);

sys/kern/uipc_mbuf.c

2271

percpu_putref(mo->mo_counters);

sys/kern/uipc_mbuf.c

2273

m->m_owner = mo;

sys/kern/uipc_mbuf.c

2277

m_claim(struct mbuf *m, struct mowner *mo)

sys/kern/uipc_mbuf.c

2280

if (m->m_owner == mo || mo == NULL)

sys/kern/uipc_mbuf.c

2284

mowner_claim(m, mo);

sys/kern/uipc_mbuf.c

2288

m_claimm(struct mbuf *m, struct mowner *mo)

sys/kern/uipc_mbuf.c

2292

m_claim(m, mo);

sys/kern/uipc_mbuf.c

345

mowner_convert_to_user(struct mowner *mo, struct mowner_user *mo_user)

sys/kern/uipc_mbuf.c

349

CTASSERT(sizeof(mo_user->mo_name) == sizeof(mo->mo_name));

sys/kern/uipc_mbuf.c

350

CTASSERT(sizeof(mo_user->mo_descr) == sizeof(mo->mo_descr));

sys/kern/uipc_mbuf.c

351

memcpy(mo_user->mo_name, mo->mo_name, sizeof(mo->mo_name));

sys/kern/uipc_mbuf.c

352

memcpy(mo_user->mo_descr, mo->mo_descr, sizeof(mo->mo_descr));

sys/kern/uipc_mbuf.c

353

percpu_foreach(mo->mo_counters, mowner_convert_to_user_cb, mo_user);

sys/kern/uipc_mbuf.c

359

struct mowner *mo;

sys/kern/uipc_mbuf.c

368

LIST_FOREACH(mo, &mowners, mo_link) {

sys/kern/uipc_mbuf.c

371

mowner_convert_to_user(mo, &mo_user);

sys/net/ppp-deflate.c

460

struct mbuf *mo, *mo_head;

sys/net/ppp-deflate.c

492

MGETHDR(mo, M_DONTWAIT, MT_DATA);

sys/net/ppp-deflate.c

493

if (mo == NULL)

sys/net/ppp-deflate.c

495

mo_head = mo;

sys/net/ppp-deflate.c

496

mo->m_len = 0;

sys/net/ppp-deflate.c

497

mo->m_next = NULL;

sys/net/ppp-deflate.c

498

MCLGET(mo, M_DONTWAIT);

sys/net/ppp-deflate.c

499

ospace = M_TRAILINGSPACE(mo);

sys/net/ppp-deflate.c

501

mo->m_data += state->hdrlen;

sys/net/ppp-deflate.c

509

wptr = mtod(mo, u_char *);

sys/net/ppp-deflate.c

565

mo->m_len = ospace;

sys/net/ppp-deflate.c

567

MGET(mo->m_next, M_DONTWAIT, MT_DATA);

sys/net/ppp-deflate.c

568

mo = mo->m_next;

sys/net/ppp-deflate.c

569

if (mo == NULL) {

sys/net/ppp-deflate.c

573

MCLGET(mo, M_DONTWAIT);

sys/net/ppp-deflate.c

574

state->strm.next_out = mtod(mo, u_char *);

sys/net/ppp-deflate.c

575

state->strm.avail_out = ospace = M_TRAILINGSPACE(mo);

sys/net/ppp-deflate.c

583

olen += (mo->m_len = ospace - state->strm.avail_out);

sys/netipsec/ipsec_mbuf.c

385

struct mbuf *mo;

sys/netipsec/ipsec_mbuf.c

405

mo = m1->m_next;

sys/netipsec/ipsec_mbuf.c

415

m1->m_next = mo;

sys/netipsec/ipsec_output.c

152

struct mbuf *mo;

sys/netipsec/ipsec_output.c

169

mo = m_makespace(m, sizeof(struct ip), hlen, &roff);

sys/netipsec/ipsec_output.c

176

mo = m_makespace(m, sizeof(struct ip6_hdr), hlen, &roff);

sys/netipsec/ipsec_output.c

187

if (mo == NULL) {

sys/netipsec/ipsec_output.c

197

udp = (struct udphdr *)(mtod(mo, char *) + roff);

sys/netipsec/xform_esp.c

685

struct mbuf *mo = NULL;

sys/netipsec/xform_esp.c

771

mo = m_makespace(m, skip, hlen, &roff);

sys/netipsec/xform_esp.c

772

if (mo == NULL) {

sys/netipsec/xform_esp.c

783

memcpy(mtod(mo, char *) + roff, &sav->spi, sizeof(uint32_t));

sys/netipsec/xform_esp.c

795

memcpy(mtod(mo,char *) + roff + sizeof(uint32_t), &replay,

sys/netipsec/xform_ipcomp.c

514

struct mbuf *m, *mo;

sys/netipsec/xform_ipcomp.c

547

mo = m_makespace(m, skip, IPCOMP_HLENGTH, &roff);

sys/netipsec/xform_ipcomp.c

548

if (mo == NULL) {

sys/netipsec/xform_ipcomp.c

556

ipcomp = (struct ipcomp *)(mtod(mo, char *) + roff);

sys/sys/mbuf.h

425

#define mowner_init_owner(mo, n, d) __nothing

sys/sys/mbuf.h

430

#define mowner_attach(mo) __nothing

sys/sys/mbuf.h

431

#define mowner_detach(mo) __nothing

sys/sys/mbuf.h

432

#define m_claimm(m, mo) __nothing

sys/sys/mbuf.h

435

#define MCLAIM(m, mo) m_claim((m), (mo))

sys/sys/mbuf.h

436

#define MOWNER_ATTACH(mo) mowner_attach(mo)

sys/sys/mbuf.h

437

#define MOWNER_DETACH(mo) mowner_detach(mo)

tests/dev/clock_subr/t_clock_subr.c

45

#define FILL(ti,ye,mo,da,wd,ho,mi,se) \

tests/dev/clock_subr/t_clock_subr.c

46

{ .time = (ti), .clock = { .dt_year = (ye), .dt_mon = (mo), .dt_day = (da), \

usr.bin/ftp/ftp.c

1842

char mo[MAXPATHLEN];

usr.bin/ftp/ftp.c

1898

(void)strlcpy(ip->mo, mapout, sizeof(ip->mo));

usr.bin/ftp/ftp.c

1899

(void)strlcpy(mapout, op->mo, sizeof(mapout));

usr.bin/netstat/mbuf.c

211

len += 10 * sizeof(*mo); /* add some slop */

usr.bin/netstat/mbuf.c

226

for (mo = (void *) data, lines = 0; len >= sizeof(*mo);

usr.bin/netstat/mbuf.c

227

len -= sizeof(*mo), mo++) {

usr.bin/netstat/mbuf.c

230

mo->mo_counter[MOWNER_COUNTER_CLAIMS] == 0 &&

usr.bin/netstat/mbuf.c

231

mo->mo_counter[MOWNER_COUNTER_EXT_CLAIMS] == 0 &&

usr.bin/netstat/mbuf.c

232

mo->mo_counter[MOWNER_COUNTER_CLUSTER_CLAIMS] == 0)

usr.bin/netstat/mbuf.c

235

mo->mo_counter[MOWNER_COUNTER_CLAIMS] ==

usr.bin/netstat/mbuf.c

236

mo->mo_counter[MOWNER_COUNTER_RELEASES] &&

usr.bin/netstat/mbuf.c

237

mo->mo_counter[MOWNER_COUNTER_EXT_CLAIMS] ==

usr.bin/netstat/mbuf.c

238

mo->mo_counter[MOWNER_COUNTER_EXT_RELEASES] &&

usr.bin/netstat/mbuf.c

239

mo->mo_counter[MOWNER_COUNTER_CLUSTER_CLAIMS] ==

usr.bin/netstat/mbuf.c

240

mo->mo_counter[MOWNER_COUNTER_CLUSTER_RELEASES])

usr.bin/netstat/mbuf.c

243

mo->mo_name, mo->mo_descr);

usr.bin/netstat/mbuf.c

251

mo->mo_counter[MOWNER_COUNTER_CLAIMS] -

usr.bin/netstat/mbuf.c

252

mo->mo_counter[MOWNER_COUNTER_RELEASES],

usr.bin/netstat/mbuf.c

253

mo->mo_counter[MOWNER_COUNTER_EXT_CLAIMS] -

usr.bin/netstat/mbuf.c

254

mo->mo_counter[MOWNER_COUNTER_EXT_RELEASES],

usr.bin/netstat/mbuf.c

255

mo->mo_counter[MOWNER_COUNTER_CLUSTER_CLAIMS] -

usr.bin/netstat/mbuf.c

256

mo->mo_counter[MOWNER_COUNTER_CLUSTER_RELEASES]);

usr.bin/netstat/mbuf.c

261

mo->mo_counter[MOWNER_COUNTER_CLAIMS],

usr.bin/netstat/mbuf.c

262

mo->mo_counter[MOWNER_COUNTER_EXT_CLAIMS],

usr.bin/netstat/mbuf.c

263

mo->mo_counter[MOWNER_COUNTER_CLUSTER_CLAIMS]);

usr.bin/netstat/mbuf.c

266

mo->mo_counter[MOWNER_COUNTER_RELEASES],

usr.bin/netstat/mbuf.c

267

mo->mo_counter[MOWNER_COUNTER_EXT_RELEASES],

usr.bin/netstat/mbuf.c

268

mo->mo_counter[MOWNER_COUNTER_CLUSTER_RELEASES]);

usr.bin/netstat/mbuf.c

98

struct mowner_user *mo;