自学教程：C++ BUILD_BUG_ON函数代码示例

int iwlagn_alive_notify(struct iwl_priv *priv){	u32 a;	unsigned long flags;	int i, chan;	u32 reg_val;	spin_lock_irqsave(&priv->lock, flags);	priv->scd_base_addr = iwl_read_prph(priv, IWLAGN_SCD_SRAM_BASE_ADDR);	a = priv->scd_base_addr + IWLAGN_SCD_CONTEXT_DATA_OFFSET;	for (; a < priv->scd_base_addr + IWLAGN_SCD_TX_STTS_BITMAP_OFFSET;		a += 4)		iwl_write_targ_mem(priv, a, 0);	for (; a < priv->scd_base_addr + IWLAGN_SCD_TRANSLATE_TBL_OFFSET;		a += 4)		iwl_write_targ_mem(priv, a, 0);	for (; a < priv->scd_base_addr +	       IWLAGN_SCD_TRANSLATE_TBL_OFFSET_QUEUE(priv->hw_params.max_txq_num); a += 4)		iwl_write_targ_mem(priv, a, 0);	iwl_write_prph(priv, IWLAGN_SCD_DRAM_BASE_ADDR,		       priv->scd_bc_tbls.dma >> 10);	/* Enable DMA channel */	for (chan = 0; chan < FH50_TCSR_CHNL_NUM ; chan++)		iwl_write_direct32(priv, FH_TCSR_CHNL_TX_CONFIG_REG(chan),				FH_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_ENABLE |				FH_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_ENABLE);	/* Update FH chicken bits */	reg_val = iwl_read_direct32(priv, FH_TX_CHICKEN_BITS_REG);	iwl_write_direct32(priv, FH_TX_CHICKEN_BITS_REG,			   reg_val | FH_TX_CHICKEN_BITS_SCD_AUTO_RETRY_EN);	iwl_write_prph(priv, IWLAGN_SCD_QUEUECHAIN_SEL,		IWLAGN_SCD_QUEUECHAIN_SEL_ALL(priv->hw_params.max_txq_num));	iwl_write_prph(priv, IWLAGN_SCD_AGGR_SEL, 0);	/* initiate the queues */	for (i = 0; i < priv->hw_params.max_txq_num; i++) {		iwl_write_prph(priv, IWLAGN_SCD_QUEUE_RDPTR(i), 0);		iwl_write_direct32(priv, HBUS_TARG_WRPTR, 0 | (i << 8));		iwl_write_targ_mem(priv, priv->scd_base_addr +				IWLAGN_SCD_CONTEXT_QUEUE_OFFSET(i), 0);		iwl_write_targ_mem(priv, priv->scd_base_addr +				IWLAGN_SCD_CONTEXT_QUEUE_OFFSET(i) +				sizeof(u32),				((SCD_WIN_SIZE <<				IWLAGN_SCD_QUEUE_CTX_REG2_WIN_SIZE_POS) &				IWLAGN_SCD_QUEUE_CTX_REG2_WIN_SIZE_MSK) |				((SCD_FRAME_LIMIT <<				IWLAGN_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS) &				IWLAGN_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK));	}	iwl_write_prph(priv, IWLAGN_SCD_INTERRUPT_MASK,			IWL_MASK(0, priv->hw_params.max_txq_num));	/* Activate all Tx DMA/FIFO channels */	priv->cfg->ops->lib->txq_set_sched(priv, IWL_MASK(0, 7));	iwlagn_set_wr_ptrs(priv, IWL_CMD_QUEUE_NUM, 0);	/* make sure all queue are not stopped */	memset(&priv->queue_stopped[0], 0, sizeof(priv->queue_stopped));	for (i = 0; i < 4; i++)		atomic_set(&priv->queue_stop_count[i], 0);	/* reset to 0 to enable all the queue first */	priv->txq_ctx_active_msk = 0;	/* map qos queues to fifos one-to-one */	BUILD_BUG_ON(ARRAY_SIZE(iwlagn_default_queue_to_tx_fifo) != 10);	for (i = 0; i < ARRAY_SIZE(iwlagn_default_queue_to_tx_fifo); i++) {		int ac = iwlagn_default_queue_to_tx_fifo[i];		iwl_txq_ctx_activate(priv, i);		if (ac == IWL_TX_FIFO_UNUSED)			continue;		iwlagn_tx_queue_set_status(priv, &priv->txq[i], ac, 0);	}	spin_unlock_irqrestore(&priv->lock, flags);	iwlagn_send_wimax_coex(priv);	iwlagn_set_Xtal_calib(priv);	iwl_send_calib_results(priv);	return 0;}

static int ps3_sys_manager_handle_event(struct ps3_system_bus_device *dev){	int result;	struct {		u8 version;		u8 type;		u8 reserved_1[2];		u32 value;		u8 reserved_2[8];	} event;	BUILD_BUG_ON(sizeof(event) != 16);	result = ps3_vuart_read(dev, &event, sizeof(event));	BUG_ON(result && "need to retry here");	if (event.version != 1) {		dev_dbg(&dev->core, "%s:%d: unsupported event version (%u)/n",			__func__, __LINE__, event.version);		return -EIO;	}	switch (event.type) {	case PS3_SM_EVENT_POWER_PRESSED:		dev_dbg(&dev->core, "%s:%d: POWER_PRESSED (%s)/n",			__func__, __LINE__,			(event.value == PS3_SM_BUTTON_EVENT_SOFT ? "soft"			: "hard"));		ps3_sm_force_power_off = 1;		wmb();		kill_cad_pid(SIGINT, 1); 		break;	case PS3_SM_EVENT_POWER_RELEASED:		dev_dbg(&dev->core, "%s:%d: POWER_RELEASED (%u ms)/n",			__func__, __LINE__, event.value);		break;	case PS3_SM_EVENT_RESET_PRESSED:		dev_dbg(&dev->core, "%s:%d: RESET_PRESSED (%s)/n",			__func__, __LINE__,			(event.value == PS3_SM_BUTTON_EVENT_SOFT ? "soft"			: "hard"));		ps3_sm_force_power_off = 0;		wmb();		kill_cad_pid(SIGINT, 1); 		break;	case PS3_SM_EVENT_RESET_RELEASED:		dev_dbg(&dev->core, "%s:%d: RESET_RELEASED (%u ms)/n",			__func__, __LINE__, event.value);		break;	case PS3_SM_EVENT_THERMAL_ALERT:		dev_dbg(&dev->core, "%s:%d: THERMAL_ALERT (zone %u)/n",			__func__, __LINE__, event.value);		pr_info("PS3 Thermal Alert Zone %u/n", event.value);		break;	case PS3_SM_EVENT_THERMAL_CLEARED:		dev_dbg(&dev->core, "%s:%d: THERMAL_CLEARED (zone %u)/n",			__func__, __LINE__, event.value);		break;	default:		dev_dbg(&dev->core, "%s:%d: unknown event (%u)/n",			__func__, __LINE__, event.type);		return -EIO;	}	return 0;}

static int efx_mcdi_bist(struct efx_nic *efx, unsigned int bist_mode,			 int *results){	unsigned int retry, i, count = 0;	size_t outlen;	u32 status;	u8 *buf, *ptr;	int rc;	buf = kzalloc(0x100, GFP_KERNEL);	if (buf == NULL)		return -ENOMEM;	BUILD_BUG_ON(MC_CMD_START_BIST_OUT_LEN != 0);	MCDI_SET_DWORD(buf, START_BIST_IN_TYPE, bist_mode);	rc = efx_mcdi_rpc(efx, MC_CMD_START_BIST, buf, MC_CMD_START_BIST_IN_LEN,			  NULL, 0, NULL);	if (rc)		goto out;		for (retry = 0; retry < 100; ++retry) {		BUILD_BUG_ON(MC_CMD_POLL_BIST_IN_LEN != 0);		rc = efx_mcdi_rpc(efx, MC_CMD_POLL_BIST, NULL, 0,				  buf, 0x100, &outlen);		if (rc)			goto out;		status = MCDI_DWORD(buf, POLL_BIST_OUT_RESULT);		if (status != MC_CMD_POLL_BIST_RUNNING)			goto finished;		msleep(100);	}	rc = -ETIMEDOUT;	goto out;finished:	results[count++] = (status == MC_CMD_POLL_BIST_PASSED) ? 1 : -1;		if (efx->phy_type == PHY_TYPE_SFT9001B &&	    (bist_mode == MC_CMD_PHY_BIST_CABLE_SHORT ||	     bist_mode == MC_CMD_PHY_BIST_CABLE_LONG)) {		ptr = MCDI_PTR(buf, POLL_BIST_OUT_SFT9001_CABLE_LENGTH_A);		if (status == MC_CMD_POLL_BIST_PASSED &&		    outlen >= MC_CMD_POLL_BIST_OUT_SFT9001_LEN) {			for (i = 0; i < 8; i++) {				results[count + i] =					EFX_DWORD_FIELD(((efx_dword_t *)ptr)[i],							EFX_DWORD_0);			}		}		count += 8;	}	rc = count;out:	kfree(buf);	return rc;}

/** * iwl_enqueue_hcmd - enqueue a uCode command * @priv: device private data point * @cmd: a point to the ucode command structure * * The function returns < 0 values to indicate the operation is * failed. On success, it turns the index (> 0) of command in the * command queue. */static int iwl_enqueue_hcmd(struct iwl_priv *priv, struct iwl_host_cmd *cmd){	struct iwl_tx_queue *txq = &priv->txq[priv->cmd_queue];	struct iwl_queue *q = &txq->q;	struct iwl_device_cmd *out_cmd;	struct iwl_cmd_meta *out_meta;	dma_addr_t phys_addr;	unsigned long flags;	u32 idx;	u16 copy_size, cmd_size;	bool is_ct_kill = false;	bool had_nocopy = false;	int i;	u8 *cmd_dest;#ifdef CONFIG_IWLWIFI_DEVICE_TRACING	const void *trace_bufs[IWL_MAX_CMD_TFDS + 1] = {};	int trace_lens[IWL_MAX_CMD_TFDS + 1] = {};	int trace_idx;#endif	if (test_bit(STATUS_FW_ERROR, &priv->status)) {		IWL_WARN(priv, "fw recovery, no hcmd send/n");		return -EIO;	}	if ((priv->ucode_owner == IWL_OWNERSHIP_TM) &&	    !(cmd->flags & CMD_ON_DEMAND)) {		IWL_DEBUG_HC(priv, "tm own the uCode, no regular hcmd send/n");		return -EIO;	}	copy_size = sizeof(out_cmd->hdr);	cmd_size = sizeof(out_cmd->hdr);	/* need one for the header if the first is NOCOPY */	BUILD_BUG_ON(IWL_MAX_CMD_TFDS > IWL_NUM_OF_TBS - 1);	for (i = 0; i < IWL_MAX_CMD_TFDS; i++) {		if (!cmd->len[i])			continue;		if (cmd->dataflags[i] & IWL_HCMD_DFL_NOCOPY) {			had_nocopy = true;		} else {			/* NOCOPY must not be followed by normal! */			if (WARN_ON(had_nocopy))				return -EINVAL;			copy_size += cmd->len[i];		}		cmd_size += cmd->len[i];	}	/*	 * If any of the command structures end up being larger than	 * the TFD_MAX_PAYLOAD_SIZE and they aren't dynamically	 * allocated into separate TFDs, then we will need to	 * increase the size of the buffers.	 */	if (WARN_ON(copy_size > TFD_MAX_PAYLOAD_SIZE))		return -EINVAL;	if (iwl_is_rfkill(priv) || iwl_is_ctkill(priv)) {		IWL_WARN(priv, "Not sending command - %s KILL/n",			 iwl_is_rfkill(priv) ? "RF" : "CT");		return -EIO;	}	spin_lock_irqsave(&priv->hcmd_lock, flags);	if (iwl_queue_space(q) < ((cmd->flags & CMD_ASYNC) ? 2 : 1)) {		spin_unlock_irqrestore(&priv->hcmd_lock, flags);		IWL_ERR(priv, "No space in command queue/n");		is_ct_kill = iwl_check_for_ct_kill(priv);		if (!is_ct_kill) {			IWL_ERR(priv, "Restarting adapter due to queue full/n");			iwlagn_fw_error(priv, false);		}		return -ENOSPC;	}	idx = get_cmd_index(q, q->write_ptr);	out_cmd = txq->cmd[idx];	out_meta = &txq->meta[idx];	memset(out_meta, 0, sizeof(*out_meta));	/* re-initialize to NULL */	if (cmd->flags & CMD_WANT_SKB)		out_meta->source = cmd;	if (cmd->flags & CMD_ASYNC)		out_meta->callback = cmd->callback;	/* set up the header *///.........这里部分代码省略.........

static int mqprio_init(struct Qdisc *sch, struct nlattr *opt){	struct net_device *dev = qdisc_dev(sch);	struct mqprio_sched *priv = qdisc_priv(sch);	struct netdev_queue *dev_queue;	struct Qdisc *qdisc;	int i, err = -EOPNOTSUPP;	struct tc_mqprio_qopt *qopt = NULL;	BUILD_BUG_ON(TC_MAX_QUEUE != TC_QOPT_MAX_QUEUE);	BUILD_BUG_ON(TC_BITMASK != TC_QOPT_BITMASK);	if (sch->parent != TC_H_ROOT)		return -EOPNOTSUPP;	if (!netif_is_multiqueue(dev))		return -EOPNOTSUPP;	if (!opt || nla_len(opt) < sizeof(*qopt))		return -EINVAL;	qopt = nla_data(opt);	if (mqprio_parse_opt(dev, qopt))		return -EINVAL;	/* pre-allocate qdisc, attachment can't fail */	priv->qdiscs = kcalloc(dev->num_tx_queues, sizeof(priv->qdiscs[0]),			       GFP_KERNEL);	if (priv->qdiscs == NULL) {		err = -ENOMEM;		goto err;	}	for (i = 0; i < dev->num_tx_queues; i++) {		dev_queue = netdev_get_tx_queue(dev, i);		qdisc = qdisc_create_dflt(dev_queue, default_qdisc_ops,					  TC_H_MAKE(TC_H_MAJ(sch->handle),						    TC_H_MIN(i + 1)));		if (qdisc == NULL) {			err = -ENOMEM;			goto err;		}		priv->qdiscs[i] = qdisc;		qdisc->flags |= TCQ_F_ONETXQUEUE;	}	/* If the mqprio options indicate that hardware should own	 * the queue mapping then run ndo_setup_tc otherwise use the	 * supplied and verified mapping	 */	if (qopt->hw) {		priv->hw_owned = 1;		err = dev->netdev_ops->ndo_setup_tc(dev, qopt->num_tc);		if (err)			goto err;	} else {		netdev_set_num_tc(dev, qopt->num_tc);		for (i = 0; i < qopt->num_tc; i++)			netdev_set_tc_queue(dev, i,					    qopt->count[i], qopt->offset[i]);	}	/* Always use supplied priority mappings */	for (i = 0; i < TC_BITMASK + 1; i++)		netdev_set_prio_tc_map(dev, i, qopt->prio_tc_map[i]);	sch->flags |= TCQ_F_MQROOT;	return 0;err:	mqprio_destroy(sch);	return err;}

void compat_show_guest_stack(struct vcpu *v, const struct cpu_user_regs *regs,                             int debug_stack_lines){    unsigned int i, *stack, addr, mask = STACK_SIZE;    stack = (unsigned int *)(unsigned long)regs->_esp;    printk("Guest stack trace from esp=%08lx:/n ", (unsigned long)stack);    if ( !__compat_access_ok(v->domain, stack, sizeof(*stack)) )    {        printk("Guest-inaccessible memory./n");        return;    }    if ( v != current )    {        struct vcpu *vcpu;        unsigned long mfn;        ASSERT(guest_kernel_mode(v, regs));        mfn = read_cr3() >> PAGE_SHIFT;        for_each_vcpu( v->domain, vcpu )            if ( pagetable_get_pfn(vcpu->arch.guest_table) == mfn )                break;        if ( !vcpu )        {            stack = do_page_walk(v, (unsigned long)stack);            if ( (unsigned long)stack < PAGE_SIZE )            {                printk("Inaccessible guest memory./n");                return;            }            mask = PAGE_SIZE;        }    }    for ( i = 0; i < debug_stack_lines * 8; i++ )    {        if ( (((long)stack - 1) ^ ((long)(stack + 1) - 1)) & mask )            break;        if ( __get_user(addr, stack) )        {            if ( i != 0 )                printk("/n    ");            printk("Fault while accessing guest memory.");            i = 1;            break;        }        if ( (i != 0) && ((i % 8) == 0) )            printk("/n ");        printk(" %08x", addr);        stack++;    }    if ( mask == PAGE_SIZE )    {        BUILD_BUG_ON(PAGE_SIZE == STACK_SIZE);        unmap_domain_page(stack);    }    if ( i == 0 )        printk("Stack empty.");    printk("/n");}

static int minix_fill_super(struct super_block *s, void *data, int silent){	struct buffer_head *bh;	struct buffer_head **map;	struct minix_super_block *ms;	struct minix3_super_block *m3s = NULL;	unsigned long i, block;	struct inode *root_inode;	struct minix_sb_info *sbi;	int ret = -EINVAL;	sbi = kzalloc(sizeof(struct minix_sb_info), GFP_KERNEL);	if (!sbi)		return -ENOMEM;	s->s_fs_info = sbi;	BUILD_BUG_ON(32 != sizeof (struct minix_inode));	BUILD_BUG_ON(64 != sizeof(struct minix2_inode));	if (!sb_set_blocksize(s, BLOCK_SIZE))		goto out_bad_hblock;	if (!(bh = sb_bread(s, 1)))		goto out_bad_sb;	ms = (struct minix_super_block *) bh->b_data;	sbi->s_ms = ms;	sbi->s_sbh = bh;	sbi->s_mount_state = ms->s_state;	sbi->s_ninodes = ms->s_ninodes;	sbi->s_nzones = ms->s_nzones;	sbi->s_imap_blocks = ms->s_imap_blocks;	sbi->s_zmap_blocks = ms->s_zmap_blocks;	sbi->s_firstdatazone = ms->s_firstdatazone;	sbi->s_log_zone_size = ms->s_log_zone_size;	sbi->s_max_size = ms->s_max_size;	s->s_magic = ms->s_magic;	if (s->s_magic == MINIX_SUPER_MAGIC) {		sbi->s_version = MINIX_V1;		sbi->s_dirsize = 16;		sbi->s_namelen = 14;		s->s_max_links = MINIX_LINK_MAX;	} else if (s->s_magic == MINIX_SUPER_MAGIC2) {		sbi->s_version = MINIX_V1;		sbi->s_dirsize = 32;		sbi->s_namelen = 30;		s->s_max_links = MINIX_LINK_MAX;	} else if (s->s_magic == MINIX2_SUPER_MAGIC) {		sbi->s_version = MINIX_V2;		sbi->s_nzones = ms->s_zones;		sbi->s_dirsize = 16;		sbi->s_namelen = 14;		s->s_max_links = MINIX2_LINK_MAX;	} else if (s->s_magic == MINIX2_SUPER_MAGIC2) {		sbi->s_version = MINIX_V2;		sbi->s_nzones = ms->s_zones;		sbi->s_dirsize = 32;		sbi->s_namelen = 30;		s->s_max_links = MINIX2_LINK_MAX;	} else if ( *(__u16 *)(bh->b_data + 24) == MINIX3_SUPER_MAGIC) {		m3s = (struct minix3_super_block *) bh->b_data;		s->s_magic = m3s->s_magic;		sbi->s_imap_blocks = m3s->s_imap_blocks;		sbi->s_zmap_blocks = m3s->s_zmap_blocks;		sbi->s_firstdatazone = m3s->s_firstdatazone;		sbi->s_log_zone_size = m3s->s_log_zone_size;		sbi->s_max_size = m3s->s_max_size;		sbi->s_ninodes = m3s->s_ninodes;		sbi->s_nzones = m3s->s_zones;		sbi->s_dirsize = 64;		sbi->s_namelen = 60;		sbi->s_version = MINIX_V3;		sbi->s_mount_state = MINIX_VALID_FS;		sb_set_blocksize(s, m3s->s_blocksize);		s->s_max_links = MINIX2_LINK_MAX;	} else		goto out_no_fs;	/*	 * Allocate the buffer map to keep the superblock small.	 */	if (sbi->s_imap_blocks == 0 || sbi->s_zmap_blocks == 0)		goto out_illegal_sb;	i = (sbi->s_imap_blocks + sbi->s_zmap_blocks) * sizeof(bh);	map = kzalloc(i, GFP_KERNEL);	if (!map)		goto out_no_map;	sbi->s_imap = &map[0];	sbi->s_zmap = &map[sbi->s_imap_blocks];	block=2;	for (i=0 ; i < sbi->s_imap_blocks ; i++) {		if (!(sbi->s_imap[i]=sb_bread(s, block)))			goto out_no_bitmap;		block++;	}	for (i=0 ; i < sbi->s_zmap_blocks ; i++) {		if (!(sbi->s_zmap[i]=sb_bread(s, block)))			goto out_no_bitmap;		block++;//.........这里部分代码省略.........

static unsigned int calc_size(int nlen){	BUILD_BUG_ON(sizeof(ino_t) != sizeof(long));	return ALIGN(sizeof(struct au_vdir_de) + nlen, sizeof(ino_t));}

static int skb_entry_is_link(const union skb_entry *list){	BUILD_BUG_ON(sizeof(list->skb) != sizeof(list->link));	return ((unsigned long)list->skb < PAGE_OFFSET);}

static int klp_find_object_symbol(const char *objname, const char *name,				  unsigned long sympos, unsigned long *addr){	struct klp_find_arg args = {		.objname = objname,		.name = name,		.addr = 0,		.count = 0,		.pos = sympos,	};	mutex_lock(&module_mutex);	if (objname)		module_kallsyms_on_each_symbol(klp_find_callback, &args);	else		kallsyms_on_each_symbol(klp_find_callback, &args);	mutex_unlock(&module_mutex);	/*	 * Ensure an address was found. If sympos is 0, ensure symbol is unique;	 * otherwise ensure the symbol position count matches sympos.	 */	if (args.addr == 0)		pr_err("symbol '%s' not found in symbol table/n", name);	else if (args.count > 1 && sympos == 0) {		pr_err("unresolvable ambiguity for symbol '%s' in object '%s'/n",		       name, objname);	} else if (sympos != args.count && sympos > 0) {		pr_err("symbol position %lu for symbol '%s' in object '%s' not found/n",		       sympos, name, objname ? objname : "vmlinux");	} else {		*addr = args.addr;		return 0;	}	*addr = 0;	return -EINVAL;}static int klp_resolve_symbols(Elf_Shdr *relasec, struct module *pmod){	int i, cnt, vmlinux, ret;	char objname[MODULE_NAME_LEN];	char symname[KSYM_NAME_LEN];	char *strtab = pmod->core_kallsyms.strtab;	Elf_Rela *relas;	Elf_Sym *sym;	unsigned long sympos, addr;	/*	 * Since the field widths for objname and symname in the sscanf()	 * call are hard-coded and correspond to MODULE_NAME_LEN and	 * KSYM_NAME_LEN respectively, we must make sure that MODULE_NAME_LEN	 * and KSYM_NAME_LEN have the values we expect them to have.	 *	 * Because the value of MODULE_NAME_LEN can differ among architectures,	 * we use the smallest/strictest upper bound possible (56, based on	 * the current definition of MODULE_NAME_LEN) to prevent overflows.	 */	BUILD_BUG_ON(MODULE_NAME_LEN < 56 || KSYM_NAME_LEN != 128);	relas = (Elf_Rela *) relasec->sh_addr;	/* For each rela in this klp relocation section */	for (i = 0; i < relasec->sh_size / sizeof(Elf_Rela); i++) {		sym = pmod->core_kallsyms.symtab + ELF_R_SYM(relas[i].r_info);		if (sym->st_shndx != SHN_LIVEPATCH) {			pr_err("symbol %s is not marked as a livepatch symbol/n",			       strtab + sym->st_name);			return -EINVAL;		}		/* Format: .klp.sym.objname.symname,sympos */		cnt = sscanf(strtab + sym->st_name,			     ".klp.sym.%55[^.].%127[^,],%lu",			     objname, symname, &sympos);		if (cnt != 3) {			pr_err("symbol %s has an incorrectly formatted name/n",			       strtab + sym->st_name);			return -EINVAL;		}		/* klp_find_object_symbol() treats a NULL objname as vmlinux */		vmlinux = !strcmp(objname, "vmlinux");		ret = klp_find_object_symbol(vmlinux ? NULL : objname,					     symname, sympos, &addr);		if (ret)			return ret;		sym->st_value = addr;	}	return 0;}

/* most free space */static void au_mfs(struct dentry *dentry, struct dentry *parent){	struct super_block *sb;	struct au_branch *br;	struct au_wbr_mfs *mfs;	struct dentry *h_parent;	aufs_bindex_t bindex, bend;	int err;	unsigned long long b, bavail;	struct path h_path;	/* reduce the stack usage */	struct kstatfs *st;	st = kmalloc(sizeof(*st), GFP_NOFS);	if (unlikely(!st)) {		AuWarn1("failed updating mfs(%d), ignored/n", -ENOMEM);		return;	}	bavail = 0;	sb = dentry->d_sb;	mfs = &au_sbi(sb)->si_wbr_mfs;	MtxMustLock(&mfs->mfs_lock);	mfs->mfs_bindex = -EROFS;	mfs->mfsrr_bytes = 0;	if (!parent) {		bindex = 0;		bend = au_sbend(sb);	} else {		bindex = au_dbstart(parent);		bend = au_dbtaildir(parent);	}	for (; bindex <= bend; bindex++) {		if (parent) {			h_parent = au_h_dptr(parent, bindex);			if (!h_parent || !h_parent->d_inode)				continue;		}		br = au_sbr(sb, bindex);		if (au_br_rdonly(br))			continue;		/* sb->s_root for NFS is unreliable */		h_path.mnt = au_br_mnt(br);		h_path.dentry = h_path.mnt->mnt_root;		err = vfs_statfs(&h_path, st);		if (unlikely(err)) {			AuWarn1("failed statfs, b%d, %d/n", bindex, err);			continue;		}		/* when the available size is equal, select the lower one */		BUILD_BUG_ON(sizeof(b) < sizeof(st->f_bavail)			     || sizeof(b) < sizeof(st->f_bsize));		b = st->f_bavail * st->f_bsize;		br->br_wbr->wbr_bytes = b;		if (b >= bavail) {			bavail = b;			mfs->mfs_bindex = bindex;			mfs->mfs_jiffy = jiffies;		}	}	mfs->mfsrr_bytes = bavail;	AuDbg("b%d/n", mfs->mfs_bindex);	kfree(st);}

int __init ubifs_init(void){	int err;	BUILD_BUG_ON(sizeof(struct ubifs_ch) != 24);	/* Make sure node sizes are 8-byte aligned */	BUILD_BUG_ON(UBIFS_CH_SZ        & 7);	BUILD_BUG_ON(UBIFS_INO_NODE_SZ  & 7);	BUILD_BUG_ON(UBIFS_DENT_NODE_SZ & 7);	BUILD_BUG_ON(UBIFS_XENT_NODE_SZ & 7);	BUILD_BUG_ON(UBIFS_DATA_NODE_SZ & 7);	BUILD_BUG_ON(UBIFS_TRUN_NODE_SZ & 7);	BUILD_BUG_ON(UBIFS_SB_NODE_SZ   & 7);	BUILD_BUG_ON(UBIFS_MST_NODE_SZ  & 7);	BUILD_BUG_ON(UBIFS_REF_NODE_SZ  & 7);	BUILD_BUG_ON(UBIFS_CS_NODE_SZ   & 7);	BUILD_BUG_ON(UBIFS_ORPH_NODE_SZ & 7);	BUILD_BUG_ON(UBIFS_MAX_DENT_NODE_SZ & 7);	BUILD_BUG_ON(UBIFS_MAX_XENT_NODE_SZ & 7);	BUILD_BUG_ON(UBIFS_MAX_DATA_NODE_SZ & 7);	BUILD_BUG_ON(UBIFS_MAX_INO_NODE_SZ  & 7);	BUILD_BUG_ON(UBIFS_MAX_NODE_SZ      & 7);	BUILD_BUG_ON(MIN_WRITE_SZ           & 7);	/* Check min. node size */	BUILD_BUG_ON(UBIFS_INO_NODE_SZ  < MIN_WRITE_SZ);	BUILD_BUG_ON(UBIFS_DENT_NODE_SZ < MIN_WRITE_SZ);	BUILD_BUG_ON(UBIFS_XENT_NODE_SZ < MIN_WRITE_SZ);	BUILD_BUG_ON(UBIFS_TRUN_NODE_SZ < MIN_WRITE_SZ);	BUILD_BUG_ON(UBIFS_MAX_DENT_NODE_SZ > UBIFS_MAX_NODE_SZ);	BUILD_BUG_ON(UBIFS_MAX_XENT_NODE_SZ > UBIFS_MAX_NODE_SZ);	BUILD_BUG_ON(UBIFS_MAX_DATA_NODE_SZ > UBIFS_MAX_NODE_SZ);	BUILD_BUG_ON(UBIFS_MAX_INO_NODE_SZ  > UBIFS_MAX_NODE_SZ);	/* Defined node sizes */	BUILD_BUG_ON(UBIFS_SB_NODE_SZ  != 4096);	BUILD_BUG_ON(UBIFS_MST_NODE_SZ != 512);	BUILD_BUG_ON(UBIFS_INO_NODE_SZ != 160);	BUILD_BUG_ON(UBIFS_REF_NODE_SZ != 64);	/*	 * We use 2 bit wide bit-fields to store compression type, which should	 * be amended if more compressors are added. The bit-fields are:	 * @compr_type in 'struct ubifs_inode', @default_compr in	 * 'struct ubifs_info' and @compr_type in 'struct ubifs_mount_opts'.	 */	BUILD_BUG_ON(UBIFS_COMPR_TYPES_CNT > 4);	/*	 * We require that PAGE_CACHE_SIZE is greater-than-or-equal-to	 * UBIFS_BLOCK_SIZE. It is assumed that both are powers of 2.	 */	if (PAGE_CACHE_SIZE < UBIFS_BLOCK_SIZE) {		ubifs_err("VFS page cache size is %u bytes, but UBIFS requires"			  " at least 4096 bytes",			  (unsigned int)PAGE_CACHE_SIZE);		return -EINVAL;	}	err = -ENOMEM;	err = ubifs_compressors_init();	if (err)		goto out_shrinker;	return 0;out_shrinker:	return err;}

static inline __always_unused void __check_code_syscall(void){	BUILD_BUG_ON(sizeof(code_syscall) != BUILTIN_SYSCALL_SIZE);	BUILD_BUG_ON(!is_log2(sizeof(code_syscall)));}

int __init enterprise_panel_init(void){	int err;	struct resource __maybe_unused *res;	struct board_info board_info;	tegra_get_board_info(&board_info);	BUILD_BUG_ON(ARRAY_SIZE(enterprise_bl_output_measured_a03) != 256);	BUILD_BUG_ON(ARRAY_SIZE(enterprise_bl_output_measured_a02) != 256);	if (board_info.fab >= BOARD_FAB_A03) {		enterprise_disp1_backlight_data.clk_div = 0x1D;		bl_output = enterprise_bl_output_measured_a03;	} else		bl_output = enterprise_bl_output_measured_a02;	enterprise_dsi.chip_id = tegra_get_chipid();	enterprise_dsi.chip_rev = tegra_get_revision();#if defined(CONFIG_TEGRA_NVMAP)	enterprise_carveouts[1].base = tegra_carveout_start;	enterprise_carveouts[1].size = tegra_carveout_size;#endif	tegra_gpio_enable(enterprise_hdmi_hpd);	gpio_request(enterprise_hdmi_hpd, "hdmi_hpd");	gpio_direction_input(enterprise_hdmi_hpd);	tegra_gpio_enable(enterprise_lcd_2d_3d);	gpio_request(enterprise_lcd_2d_3d, "lcd_2d_3d");	gpio_direction_output(enterprise_lcd_2d_3d, 0);	enterprise_stereo_set_mode(enterprise_stereo.mode_2d_3d);	tegra_gpio_enable(enterprise_lcd_swp_pl);	gpio_request(enterprise_lcd_swp_pl, "lcd_swp_pl");	gpio_direction_output(enterprise_lcd_swp_pl, 0);	enterprise_stereo_set_orientation(enterprise_stereo.orientation);#if !(DC_CTRL_MODE & TEGRA_DC_OUT_ONE_SHOT_MODE)	tegra_gpio_enable(enterprise_lcd_te);	gpio_request(enterprise_lcd_swp_pl, "lcd_te");	gpio_direction_input(enterprise_lcd_te);#endif#ifdef CONFIG_HAS_EARLYSUSPEND	enterprise_panel_early_suspender.suspend = enterprise_panel_early_suspend;	enterprise_panel_early_suspender.resume = enterprise_panel_late_resume;	enterprise_panel_early_suspender.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;	register_early_suspend(&enterprise_panel_early_suspender);#endif#ifdef CONFIG_TEGRA_GRHOST	err = nvhost_device_register(&tegra_grhost_device);	if (err)		return err;#endif	err = platform_add_devices(enterprise_gfx_devices,				ARRAY_SIZE(enterprise_gfx_devices));#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)	res = nvhost_get_resource_byname(&enterprise_disp1_device,					 IORESOURCE_MEM, "fbmem");	res->start = tegra_fb_start;	res->end = tegra_fb_start + tegra_fb_size - 1;#endif	/* Copy the bootloader fb to the fb. */	tegra_move_framebuffer(tegra_fb_start, tegra_bootloader_fb_start,		min(tegra_fb_size, tegra_bootloader_fb_size));#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)	if (!err)		err = nvhost_device_register(&enterprise_disp1_device);	res = nvhost_get_resource_byname(&enterprise_disp2_device,					 IORESOURCE_MEM, "fbmem");	res->start = tegra_fb2_start;	res->end = tegra_fb2_start + tegra_fb2_size - 1;	if (!err)		err = nvhost_device_register(&enterprise_disp2_device);#endif#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_NVAVP)	if (!err)		err = nvhost_device_register(&nvavp_device);#endif	if (!err)		err = platform_add_devices(enterprise_bl_devices,				ARRAY_SIZE(enterprise_bl_devices));	return err;}

/* This call performs hardware-specific global initialisation, such as * defining the descriptor cache sizes and number of RSS channels. * It does not set up any buffers, descriptor rings or event queues. */static int siena_init_nic(struct efx_nic *efx){	efx_oword_t temp;	int rc;	/* Recover from a failed assertion post-reset */	rc = efx_mcdi_handle_assertion(efx);	if (rc)		return rc;	/* Squash TX of packets of 16 bytes or less */	efx_reado(efx, &temp, FR_AZ_TX_RESERVED);	EFX_SET_OWORD_FIELD(temp, FRF_BZ_TX_FLUSH_MIN_LEN_EN, 1);	efx_writeo(efx, &temp, FR_AZ_TX_RESERVED);	/* Do not enable TX_NO_EOP_DISC_EN, since it limits packets to 16	 * descriptors (which is bad).	 */	efx_reado(efx, &temp, FR_AZ_TX_CFG);	EFX_SET_OWORD_FIELD(temp, FRF_AZ_TX_NO_EOP_DISC_EN, 0);	EFX_SET_OWORD_FIELD(temp, FRF_CZ_TX_FILTER_EN_BIT, 1);	efx_writeo(efx, &temp, FR_AZ_TX_CFG);	efx_reado(efx, &temp, FR_AZ_RX_CFG);	EFX_SET_OWORD_FIELD(temp, FRF_BZ_RX_DESC_PUSH_EN, 0);	EFX_SET_OWORD_FIELD(temp, FRF_BZ_RX_INGR_EN, 1);	/* Enable hash insertion. This is broken for the 'Falcon' hash	 * if IPv6 hashing is also enabled, so also select Toeplitz	 * TCP/IPv4 and IPv4 hashes. */	EFX_SET_OWORD_FIELD(temp, FRF_BZ_RX_HASH_INSRT_HDR, 1);	EFX_SET_OWORD_FIELD(temp, FRF_BZ_RX_HASH_ALG, 1);	EFX_SET_OWORD_FIELD(temp, FRF_BZ_RX_IP_HASH, 1);	EFX_SET_OWORD_FIELD(temp, FRF_BZ_RX_USR_BUF_SIZE,			    EFX_RX_USR_BUF_SIZE >> 5);	efx_writeo(efx, &temp, FR_AZ_RX_CFG);	/* Set hash key for IPv4 */	memcpy(&temp, efx->rx_hash_key, sizeof(temp));	efx_writeo(efx, &temp, FR_BZ_RX_RSS_TKEY);	/* Enable IPv6 RSS */	BUILD_BUG_ON(sizeof(efx->rx_hash_key) <		     2 * sizeof(temp) + FRF_CZ_RX_RSS_IPV6_TKEY_HI_WIDTH / 8 ||		     FRF_CZ_RX_RSS_IPV6_TKEY_HI_LBN != 0);	memcpy(&temp, efx->rx_hash_key, sizeof(temp));	efx_writeo(efx, &temp, FR_CZ_RX_RSS_IPV6_REG1);	memcpy(&temp, efx->rx_hash_key + sizeof(temp), sizeof(temp));	efx_writeo(efx, &temp, FR_CZ_RX_RSS_IPV6_REG2);	EFX_POPULATE_OWORD_2(temp, FRF_CZ_RX_RSS_IPV6_THASH_ENABLE, 1,			     FRF_CZ_RX_RSS_IPV6_IP_THASH_ENABLE, 1);	memcpy(&temp, efx->rx_hash_key + 2 * sizeof(temp),	       FRF_CZ_RX_RSS_IPV6_TKEY_HI_WIDTH / 8);	efx_writeo(efx, &temp, FR_CZ_RX_RSS_IPV6_REG3);	/* Enable event logging */	rc = efx_mcdi_log_ctrl(efx, true, false, 0);	if (rc)		return rc;	/* Set destination of both TX and RX Flush events */	EFX_POPULATE_OWORD_1(temp, FRF_BZ_FLS_EVQ_ID, 0);	efx_writeo(efx, &temp, FR_BZ_DP_CTRL);	EFX_POPULATE_OWORD_1(temp, FRF_CZ_USREV_DIS, 1);	efx_writeo(efx, &temp, FR_CZ_USR_EV_CFG);	efx_nic_init_common(efx);	return 0;}

static int qmi_wwan_bind(struct usbnet *dev, struct usb_interface *intf){	int status = -1;	u8 *buf = intf->cur_altsetting->extra;	int len = intf->cur_altsetting->extralen;	struct usb_interface_descriptor *desc = &intf->cur_altsetting->desc;	struct usb_cdc_union_desc *cdc_union = NULL;	struct usb_cdc_ether_desc *cdc_ether = NULL;	u32 found = 0;	struct usb_driver *driver = driver_of(intf);	struct qmi_wwan_state *info = (void *)&dev->data;	BUILD_BUG_ON((sizeof(((struct usbnet *)0)->data) < sizeof(struct qmi_wwan_state)));	/* require a single interrupt status endpoint for subdriver */	if (intf->cur_altsetting->desc.bNumEndpoints != 1)		goto err;	while (len > 3) {		struct usb_descriptor_header *h = (void *)buf;		/* ignore any misplaced descriptors */		if (h->bDescriptorType != USB_DT_CS_INTERFACE)			goto next_desc;		/* buf[2] is CDC descriptor subtype */		switch (buf[2]) {		case USB_CDC_HEADER_TYPE:			if (found & 1 << USB_CDC_HEADER_TYPE) {				dev_dbg(&intf->dev, "extra CDC header/n");				goto err;			}			if (h->bLength != sizeof(struct usb_cdc_header_desc)) {				dev_dbg(&intf->dev, "CDC header len %u/n", h->bLength);				goto err;			}			break;		case USB_CDC_UNION_TYPE:			if (found & 1 << USB_CDC_UNION_TYPE) {				dev_dbg(&intf->dev, "extra CDC union/n");				goto err;			}			if (h->bLength != sizeof(struct usb_cdc_union_desc)) {				dev_dbg(&intf->dev, "CDC union len %u/n", h->bLength);				goto err;			}			cdc_union = (struct usb_cdc_union_desc *)buf;			break;		case USB_CDC_ETHERNET_TYPE:			if (found & 1 << USB_CDC_ETHERNET_TYPE) {				dev_dbg(&intf->dev, "extra CDC ether/n");				goto err;			}			if (h->bLength != sizeof(struct usb_cdc_ether_desc)) {				dev_dbg(&intf->dev, "CDC ether len %u/n",  h->bLength);				goto err;			}			cdc_ether = (struct usb_cdc_ether_desc *)buf;			break;		}		/*		 * Remember which CDC functional descriptors we've seen.  Works		 * for all types we care about, of which USB_CDC_ETHERNET_TYPE		 * (0x0f) is the highest numbered		 */		if (buf[2] < 32)			found |= 1 << buf[2];next_desc:		len -= h->bLength;		buf += h->bLength;	}	/* did we find all the required ones? */	if (!(found & (1 << USB_CDC_HEADER_TYPE)) ||	    !(found & (1 << USB_CDC_UNION_TYPE))) {		dev_err(&intf->dev, "CDC functional descriptors missing/n");		goto err;	}	/* verify CDC Union */	if (desc->bInterfaceNumber != cdc_union->bMasterInterface0) {		dev_err(&intf->dev, "bogus CDC Union: master=%u/n", cdc_union->bMasterInterface0);		goto err;	}	/* need to save these for unbind */	info->control = intf;	info->data = usb_ifnum_to_if(dev->udev,	cdc_union->bSlaveInterface0);	if (!info->data) {		dev_err(&intf->dev, "bogus CDC Union: slave=%u/n", cdc_union->bSlaveInterface0);		goto err;	}	/* errors aren't fatal - we can live with the dynamic address */	if (cdc_ether) {		dev->hard_mtu = le16_to_cpu(cdc_ether->wMaxSegmentSize);		usbnet_get_ethernet_addr(dev, cdc_ether->iMACAddress);	}//.........这里部分代码省略.........

static int efx_mcdi_phy_probe(struct efx_nic *efx){	struct efx_mcdi_phy_data *phy_data;	u8 outbuf[MC_CMD_GET_LINK_OUT_LEN];	u32 caps;	int rc;		phy_data = kzalloc(sizeof(*phy_data), GFP_KERNEL);	if (phy_data == NULL)		return -ENOMEM;	rc = efx_mcdi_get_phy_cfg(efx, phy_data);	if (rc != 0)		goto fail;		BUILD_BUG_ON(MC_CMD_GET_LINK_IN_LEN != 0);	rc = efx_mcdi_rpc(efx, MC_CMD_GET_LINK, NULL, 0,			  outbuf, sizeof(outbuf), NULL);	if (rc)		goto fail;		efx->phy_data = phy_data;	efx->phy_type = phy_data->type;	efx->mdio_bus = phy_data->channel;	efx->mdio.prtad = phy_data->port;	efx->mdio.mmds = phy_data->mmd_mask & ~(1 << MC_CMD_MMD_CLAUSE22);	efx->mdio.mode_support = 0;	if (phy_data->mmd_mask & (1 << MC_CMD_MMD_CLAUSE22))		efx->mdio.mode_support |= MDIO_SUPPORTS_C22;	if (phy_data->mmd_mask & ~(1 << MC_CMD_MMD_CLAUSE22))		efx->mdio.mode_support |= MDIO_SUPPORTS_C45 | MDIO_EMULATE_C22;	caps = MCDI_DWORD(outbuf, GET_LINK_OUT_CAP);	if (caps & (1 << MC_CMD_PHY_CAP_AN_LBN))		efx->link_advertising =			mcdi_to_ethtool_cap(phy_data->media, caps);	else		phy_data->forced_cap = caps;		BUILD_BUG_ON(LOOPBACK_NONE != MC_CMD_LOOPBACK_NONE);	BUILD_BUG_ON(LOOPBACK_DATA != MC_CMD_LOOPBACK_DATA);	BUILD_BUG_ON(LOOPBACK_GMAC != MC_CMD_LOOPBACK_GMAC);	BUILD_BUG_ON(LOOPBACK_XGMII != MC_CMD_LOOPBACK_XGMII);	BUILD_BUG_ON(LOOPBACK_XGXS != MC_CMD_LOOPBACK_XGXS);	BUILD_BUG_ON(LOOPBACK_XAUI != MC_CMD_LOOPBACK_XAUI);	BUILD_BUG_ON(LOOPBACK_GMII != MC_CMD_LOOPBACK_GMII);	BUILD_BUG_ON(LOOPBACK_SGMII != MC_CMD_LOOPBACK_SGMII);	BUILD_BUG_ON(LOOPBACK_XGBR != MC_CMD_LOOPBACK_XGBR);	BUILD_BUG_ON(LOOPBACK_XFI != MC_CMD_LOOPBACK_XFI);	BUILD_BUG_ON(LOOPBACK_XAUI_FAR != MC_CMD_LOOPBACK_XAUI_FAR);	BUILD_BUG_ON(LOOPBACK_GMII_FAR != MC_CMD_LOOPBACK_GMII_FAR);	BUILD_BUG_ON(LOOPBACK_SGMII_FAR != MC_CMD_LOOPBACK_SGMII_FAR);	BUILD_BUG_ON(LOOPBACK_XFI_FAR != MC_CMD_LOOPBACK_XFI_FAR);	BUILD_BUG_ON(LOOPBACK_GPHY != MC_CMD_LOOPBACK_GPHY);	BUILD_BUG_ON(LOOPBACK_PHYXS != MC_CMD_LOOPBACK_PHYXS);	BUILD_BUG_ON(LOOPBACK_PCS != MC_CMD_LOOPBACK_PCS);	BUILD_BUG_ON(LOOPBACK_PMAPMD != MC_CMD_LOOPBACK_PMAPMD);	BUILD_BUG_ON(LOOPBACK_XPORT != MC_CMD_LOOPBACK_XPORT);	BUILD_BUG_ON(LOOPBACK_XGMII_WS != MC_CMD_LOOPBACK_XGMII_WS);	BUILD_BUG_ON(LOOPBACK_XAUI_WS != MC_CMD_LOOPBACK_XAUI_WS);	BUILD_BUG_ON(LOOPBACK_XAUI_WS_FAR != MC_CMD_LOOPBACK_XAUI_WS_FAR);	BUILD_BUG_ON(LOOPBACK_XAUI_WS_NEAR != MC_CMD_LOOPBACK_XAUI_WS_NEAR);	BUILD_BUG_ON(LOOPBACK_GMII_WS != MC_CMD_LOOPBACK_GMII_WS);	BUILD_BUG_ON(LOOPBACK_XFI_WS != MC_CMD_LOOPBACK_XFI_WS);	BUILD_BUG_ON(LOOPBACK_XFI_WS_FAR != MC_CMD_LOOPBACK_XFI_WS_FAR);	BUILD_BUG_ON(LOOPBACK_PHYXS_WS != MC_CMD_LOOPBACK_PHYXS_WS);	rc = efx_mcdi_loopback_modes(efx, &efx->loopback_modes);	if (rc != 0)		goto fail;	efx->loopback_modes &= ~(1 << LOOPBACK_NONE);		efx_mcdi_phy_decode_link(		efx, &efx->link_state,		MCDI_DWORD(outbuf, GET_LINK_OUT_LINK_SPEED),		MCDI_DWORD(outbuf, GET_LINK_OUT_FLAGS),		MCDI_DWORD(outbuf, GET_LINK_OUT_FCNTL));		efx->wanted_fc = EFX_FC_RX | EFX_FC_TX;	if (phy_data->supported_cap & (1 << MC_CMD_PHY_CAP_AN_LBN))		efx->wanted_fc |= EFX_FC_AUTO;	efx_link_set_wanted_fc(efx, efx->wanted_fc);	return 0;fail:	kfree(phy_data);	return rc;}

static voidminstrel_ht_update_caps(void *priv, struct ieee80211_supported_band *sband,			struct cfg80211_chan_def *chandef,                        struct ieee80211_sta *sta, void *priv_sta){	struct minstrel_priv *mp = priv;	struct minstrel_ht_sta_priv *msp = priv_sta;	struct minstrel_ht_sta *mi = &msp->ht;	struct ieee80211_mcs_info *mcs = &sta->ht_cap.mcs;	u16 sta_cap = sta->ht_cap.cap;	int n_supported = 0;	int ack_dur;	int stbc;	int i;	/* fall back to the old minstrel for legacy stations */	if (!sta->ht_cap.ht_supported)		goto use_legacy;	BUILD_BUG_ON(ARRAY_SIZE(minstrel_mcs_groups) !=		MINSTREL_MAX_STREAMS * MINSTREL_STREAM_GROUPS + 1);	msp->is_ht = true;	memset(mi, 0, sizeof(*mi));	mi->sta = sta;	mi->stats_update = jiffies;	ack_dur = ieee80211_frame_duration(sband->band, 10, 60, 1, 1, 0);	mi->overhead = ieee80211_frame_duration(sband->band, 0, 60, 1, 1, 0);	mi->overhead += ack_dur;	mi->overhead_rtscts = mi->overhead + 2 * ack_dur;	mi->avg_ampdu_len = MINSTREL_FRAC(1, 1);	/* When using MRR, sample more on the first attempt, without delay */	if (mp->has_mrr) {		mi->sample_count = 16;		mi->sample_wait = 0;	} else {		mi->sample_count = 8;		mi->sample_wait = 8;	}	mi->sample_tries = 4;	stbc = (sta_cap & IEEE80211_HT_CAP_RX_STBC) >>		IEEE80211_HT_CAP_RX_STBC_SHIFT;	mi->tx_flags |= stbc << IEEE80211_TX_CTL_STBC_SHIFT;	if (sta_cap & IEEE80211_HT_CAP_LDPC_CODING)		mi->tx_flags |= IEEE80211_TX_CTL_LDPC;	for (i = 0; i < ARRAY_SIZE(mi->groups); i++) {		mi->groups[i].supported = 0;		if (i == MINSTREL_CCK_GROUP) {			minstrel_ht_update_cck(mp, mi, sband, sta);			continue;		}		if (minstrel_mcs_groups[i].flags & IEEE80211_TX_RC_SHORT_GI) {			if (minstrel_mcs_groups[i].flags & IEEE80211_TX_RC_40_MHZ_WIDTH) {				if (!(sta_cap & IEEE80211_HT_CAP_SGI_40))					continue;			} else {				if (!(sta_cap & IEEE80211_HT_CAP_SGI_20))					continue;			}		}		if (minstrel_mcs_groups[i].flags & IEEE80211_TX_RC_40_MHZ_WIDTH &&		    sta->bandwidth < IEEE80211_STA_RX_BW_40)			continue;		/* Mark MCS > 7 as unsupported if STA is in static SMPS mode */		if (sta->smps_mode == IEEE80211_SMPS_STATIC &&		    minstrel_mcs_groups[i].streams > 1)			continue;		mi->groups[i].supported =			mcs->rx_mask[minstrel_mcs_groups[i].streams - 1];		if (mi->groups[i].supported)			n_supported++;	}	if (!n_supported)		goto use_legacy;	/* create an initial rate table with the lowest supported rates */	minstrel_ht_update_stats(mp, mi);	minstrel_ht_update_rates(mp, mi);	return;use_legacy:	msp->is_ht = false;	memset(&msp->legacy, 0, sizeof(msp->legacy));	msp->legacy.r = msp->ratelist;	msp->legacy.sample_table = msp->sample_table;	return mac80211_minstrel.rate_init(priv, sband, chandef, sta,//.........这里部分代码省略.........

int __cfg80211_join_mesh(struct cfg80211_registered_device *rdev,			 struct net_device *dev,			 struct mesh_setup *setup,			 const struct mesh_config *conf){	struct wireless_dev *wdev = dev->ieee80211_ptr;	int err;	BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN != IEEE80211_MAX_MESH_ID_LEN);	ASSERT_WDEV_LOCK(wdev);	if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)		return -EOPNOTSUPP;	if (!(rdev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&	      setup->is_secure)		return -EOPNOTSUPP;	if (wdev->mesh_id_len)		return -EALREADY;	if (!setup->mesh_id_len)		return -EINVAL;	if (!rdev->ops->join_mesh)		return -EOPNOTSUPP;	if (!setup->chandef.chan) {		/* if no channel explicitly given, use preset channel */		setup->chandef = wdev->preset_chandef;	}	if (!setup->chandef.chan) {		/* if we don't have that either, use the first usable channel */		enum ieee80211_band band;		for (band = 0; band < IEEE80211_NUM_BANDS; band++) {			struct ieee80211_supported_band *sband;			struct ieee80211_channel *chan;			int i;			sband = rdev->wiphy.bands[band];			if (!sband)				continue;			for (i = 0; i < sband->n_channels; i++) {				chan = &sband->channels[i];				if (chan->flags & (IEEE80211_CHAN_NO_IR |						   IEEE80211_CHAN_DISABLED |						   IEEE80211_CHAN_RADAR))					continue;				setup->chandef.chan = chan;				break;			}			if (setup->chandef.chan)				break;		}		/* no usable channel ... */		if (!setup->chandef.chan)			return -EINVAL;		setup->chandef.width = NL80211_CHAN_WIDTH_20_NOHT;		setup->chandef.center_freq1 = setup->chandef.chan->center_freq;	}	/*	 * check if basic rates are available otherwise use mandatory rates as	 * basic rates	 */	if (!setup->basic_rates) {		enum nl80211_bss_scan_width scan_width;		struct ieee80211_supported_band *sband =				rdev->wiphy.bands[setup->chandef.chan->band];		scan_width = cfg80211_chandef_to_scan_width(&setup->chandef);		setup->basic_rates = ieee80211_mandatory_rates(sband,							       scan_width);	}	if (!cfg80211_reg_can_beacon(&rdev->wiphy, &setup->chandef))		return -EINVAL;	err = rdev_join_mesh(rdev, dev, conf, setup);	if (!err) {		memcpy(wdev->ssid, setup->mesh_id, setup->mesh_id_len);		wdev->mesh_id_len = setup->mesh_id_len;		wdev->chandef = setup->chandef;	}	return err;}

int au_si_alloc(struct super_block *sb){	int err, i;	struct au_sbinfo *sbinfo;	static struct lock_class_key aufs_si;	err = -ENOMEM;	sbinfo = kzalloc(sizeof(*sbinfo), GFP_NOFS);	if (unlikely(!sbinfo))		goto out;	BUILD_BUG_ON(sizeof(unsigned long) !=		     sizeof(*sbinfo->au_si_pid.bitmap));	sbinfo->au_si_pid.bitmap = kcalloc(BITS_TO_LONGS(PID_MAX_DEFAULT),					sizeof(*sbinfo->au_si_pid.bitmap),					GFP_NOFS);	if (unlikely(!sbinfo->au_si_pid.bitmap))		goto out_sbinfo;	/* will be reallocated separately */	sbinfo->si_branch = kzalloc(sizeof(*sbinfo->si_branch), GFP_NOFS);	if (unlikely(!sbinfo->si_branch))		goto out_pidmap;	err = sysaufs_si_init(sbinfo);	if (unlikely(err))		goto out_br;	au_nwt_init(&sbinfo->si_nowait);	au_rw_init_wlock(&sbinfo->si_rwsem);	au_rw_class(&sbinfo->si_rwsem, &aufs_si);	spin_lock_init(&sbinfo->au_si_pid.tree_lock);	INIT_RADIX_TREE(&sbinfo->au_si_pid.tree, GFP_ATOMIC | __GFP_NOFAIL);	atomic_long_set(&sbinfo->si_ninodes, 0);	atomic_long_set(&sbinfo->si_nfiles, 0);	sbinfo->si_bend = -1;	sbinfo->si_last_br_id = AUFS_BRANCH_MAX / 2;	sbinfo->si_wbr_copyup = AuWbrCopyup_Def;	sbinfo->si_wbr_create = AuWbrCreate_Def;	sbinfo->si_wbr_copyup_ops = au_wbr_copyup_ops + sbinfo->si_wbr_copyup;	sbinfo->si_wbr_create_ops = au_wbr_create_ops + sbinfo->si_wbr_create;	sbinfo->si_mntflags = au_opts_plink(AuOpt_Def);	sbinfo->si_xino_jiffy = jiffies;	sbinfo->si_xino_expire		= msecs_to_jiffies(AUFS_XINO_DEF_SEC * MSEC_PER_SEC);	mutex_init(&sbinfo->si_xib_mtx);	sbinfo->si_xino_brid = -1;	/* leave si_xib_last_pindex and si_xib_next_bit */	sbinfo->si_rdcache = msecs_to_jiffies(AUFS_RDCACHE_DEF * MSEC_PER_SEC);	sbinfo->si_rdblk = AUFS_RDBLK_DEF;	sbinfo->si_rdhash = AUFS_RDHASH_DEF;	sbinfo->si_dirwh = AUFS_DIRWH_DEF;	for (i = 0; i < AuPlink_NHASH; i++)		au_sphl_init(sbinfo->si_plink + i);	init_waitqueue_head(&sbinfo->si_plink_wq);	spin_lock_init(&sbinfo->si_plink_maint_lock);	/* leave other members for sysaufs and si_mnt. */	sbinfo->si_sb = sb;	sb->s_fs_info = sbinfo;	si_pid_set(sb);	au_debug_sbinfo_init(sbinfo);	return 0; /* success */out_br:	kfree(sbinfo->si_branch);out_pidmap:	kfree(sbinfo->au_si_pid.bitmap);out_sbinfo:	kfree(sbinfo);out:	return err;}

static int radeon_move_blit(struct ttm_buffer_object *bo,			bool evict, int no_wait_reserve, bool no_wait_gpu,			struct ttm_mem_reg *new_mem,			struct ttm_mem_reg *old_mem){	struct radeon_device *rdev;	uint64_t old_start, new_start;	struct radeon_fence *fence;	int r, i;	rdev = radeon_get_rdev(bo->bdev);	r = radeon_fence_create(rdev, &fence, radeon_copy_ring_index(rdev));	if (unlikely(r)) {		return r;	}	old_start = old_mem->start << PAGE_SHIFT;	new_start = new_mem->start << PAGE_SHIFT;	switch (old_mem->mem_type) {	case TTM_PL_VRAM:		old_start += rdev->mc.vram_start;		break;	case TTM_PL_TT:		old_start += rdev->mc.gtt_start;		break;	default:		DRM_ERROR("Unknown placement %d/n", old_mem->mem_type);		return -EINVAL;	}	switch (new_mem->mem_type) {	case TTM_PL_VRAM:		new_start += rdev->mc.vram_start;		break;	case TTM_PL_TT:		new_start += rdev->mc.gtt_start;		break;	default:		DRM_ERROR("Unknown placement %d/n", old_mem->mem_type);		return -EINVAL;	}	if (!rdev->ring[radeon_copy_ring_index(rdev)].ready) {		DRM_ERROR("Trying to move memory with ring turned off./n");		return -EINVAL;	}	BUILD_BUG_ON((PAGE_SIZE % RADEON_GPU_PAGE_SIZE) != 0);	/* sync other rings */	if (rdev->family >= CHIP_R600) {		for (i = 0; i < RADEON_NUM_RINGS; ++i) {			/* no need to sync to our own or unused rings */			if (i == radeon_copy_ring_index(rdev) || !rdev->ring[i].ready)				continue;			if (!fence->semaphore) {				r = radeon_semaphore_create(rdev, &fence->semaphore);				/* FIXME: handle semaphore error */				if (r)					continue;			}			r = radeon_ring_lock(rdev, &rdev->ring[i], 3);			/* FIXME: handle ring lock error */			if (r)				continue;			radeon_semaphore_emit_signal(rdev, i, fence->semaphore);			radeon_ring_unlock_commit(rdev, &rdev->ring[i]);			r = radeon_ring_lock(rdev, &rdev->ring[radeon_copy_ring_index(rdev)], 3);			/* FIXME: handle ring lock error */			if (r)				continue;			radeon_semaphore_emit_wait(rdev, radeon_copy_ring_index(rdev), fence->semaphore);			radeon_ring_unlock_commit(rdev, &rdev->ring[radeon_copy_ring_index(rdev)]);		}	}	r = radeon_copy(rdev, old_start, new_start,			new_mem->num_pages * (PAGE_SIZE / RADEON_GPU_PAGE_SIZE), /* GPU pages */			fence);	/* FIXME: handle copy error */	r = ttm_bo_move_accel_cleanup(bo, (void *)fence, NULL,				      evict, no_wait_reserve, no_wait_gpu, new_mem);	radeon_fence_unref(&fence);	return r;}

static int restore_creds(CredsEntry *ce){	int b, i, ret;	struct cap_header hdr;	struct cap_data data[_LINUX_CAPABILITY_U32S_3];	/*	 * We're still root here and thus can do it without failures.	 */	/*	 * First -- set the SECURE_NO_SETUID_FIXUP bit not to	 * lose caps bits when changing xids.	 */	ret = sys_prctl(PR_SET_SECUREBITS, 1 << SECURE_NO_SETUID_FIXUP, 0, 0, 0);	if (ret) {		pr_err("Unable to set SECURE_NO_SETUID_FIXUP: %d/n", ret);		return -1;	}	/*	 * Second -- restore xids. Since we still have the CAP_SETUID	 * capability nothing should fail. But call the setfsXid last	 * to override the setresXid settings.	 */	ret = sys_setresuid(ce->uid, ce->euid, ce->suid);	if (ret) {		pr_err("Unable to set real, effective and saved user ID: %d/n", ret);		return -1;	}	sys_setfsuid(ce->fsuid);	if (sys_setfsuid(-1) != ce->fsuid) {		pr_err("Unable to set fsuid/n");		return -1;	}	ret = sys_setresgid(ce->gid, ce->egid, ce->sgid);	if (ret) {		pr_err("Unable to set real, effective and saved group ID: %d/n", ret);		return -1;	}	sys_setfsgid(ce->fsgid);	if (sys_setfsgid(-1) != ce->fsgid) {		pr_err("Unable to set fsgid/n");		return -1;	}	/*	 * Third -- restore securebits. We don't need them in any	 * special state any longer.	 */	ret = sys_prctl(PR_SET_SECUREBITS, ce->secbits, 0, 0, 0);	if (ret) {		pr_err("Unable to set PR_SET_SECUREBITS: %d/n", ret);		return -1;	}	/*	 * Fourth -- trim bset. This can only be done while	 * having the CAP_SETPCAP capablity.	 */	for (b = 0; b < CR_CAP_SIZE; b++) {		for (i = 0; i < 32; i++) {			if (b * 32 + i > cap_last_cap)				break;			if (ce->cap_bnd[b] & (1 << i))				/* already set */				continue;			ret = sys_prctl(PR_CAPBSET_DROP, i + b * 32, 0, 0, 0);			if (ret) {				pr_err("Unable to drop capability %d: %d/n",								i + b * 32, ret);				return -1;			}		}	}	/*	 * Fifth -- restore caps. Nothing but cap bits are changed	 * at this stage, so just do it.	 */	hdr.version = _LINUX_CAPABILITY_VERSION_3;	hdr.pid = 0;	BUILD_BUG_ON(_LINUX_CAPABILITY_U32S_3 != CR_CAP_SIZE);	for (i = 0; i < CR_CAP_SIZE; i++) {		data[i].eff = ce->cap_eff[i];		data[i].prm = ce->cap_prm[i];		data[i].inh = ce->cap_inh[i];	}	ret = sys_capset(&hdr, data);//.........这里部分代码省略.........

//.........这里部分代码省略.........			}			local->hw.wiphy->cipher_suites = suites;			local->hw.wiphy->n_cipher_suites = w;			local->wiphy_ciphers_allocated = true;		}	}	if (!local->ops->remain_on_channel)		local->hw.wiphy->max_remain_on_channel_duration = 5000;	result = wiphy_register(local->hw.wiphy);	if (result < 0)		goto fail_wiphy_register;	/*	 * We use the number of queues for feature tests (QoS, HT) internally	 * so restrict them appropriately.	 */	if (hw->queues > IEEE80211_MAX_QUEUES)		hw->queues = IEEE80211_MAX_QUEUES;	local->workqueue =		alloc_ordered_workqueue(wiphy_name(local->hw.wiphy), 0);	if (!local->workqueue) {		result = -ENOMEM;		goto fail_workqueue;	}	/*	 * The hardware needs headroom for sending the frame,	 * and we need some headroom for passing the frame to monitor	 * interfaces, but never both at the same time.	 */	BUILD_BUG_ON(IEEE80211_TX_STATUS_HEADROOM !=			sizeof(struct ieee80211_tx_status_rtap_hdr));	local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom,				   sizeof(struct ieee80211_tx_status_rtap_hdr));	debugfs_hw_add(local);	/*	 * if the driver doesn't specify a max listen interval we	 * use 5 which should be a safe default	 */	if (local->hw.max_listen_interval == 0)		local->hw.max_listen_interval = 5;	local->hw.conf.listen_interval = local->hw.max_listen_interval;	local->dynamic_ps_forced_timeout = -1;	result = sta_info_start(local);	if (result < 0)		goto fail_sta_info;	result = ieee80211_wep_init(local);	if (result < 0)		wiphy_debug(local->hw.wiphy, "Failed to initialize wep: %d/n",			    result);	rtnl_lock();	result = ieee80211_init_rate_ctrl_alg(local,					      hw->rate_control_algorithm);	if (result < 0) {		wiphy_debug(local->hw.wiphy,

static int cap1106_i2c_probe(struct i2c_client *i2c_client,			     const struct i2c_device_id *id){	struct device *dev = &i2c_client->dev;	struct cap1106_priv *priv;	struct device_node *node;	int i, error, irq, gain = 0;	unsigned int val, rev;	u32 gain32, keycodes[CAP1106_NUM_CHN];	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);	if (!priv)		return -ENOMEM;	priv->regmap = devm_regmap_init_i2c(i2c_client, &cap1106_regmap_config);	if (IS_ERR(priv->regmap))		return PTR_ERR(priv->regmap);	error = regmap_read(priv->regmap, CAP1106_REG_PRODUCT_ID, &val);	if (error)		return error;	if (val != CAP1106_PRODUCT_ID) {		dev_err(dev, "Product ID: Got 0x%02x, expected 0x%02x/n",			val, CAP1106_PRODUCT_ID);		return -ENODEV;	}	error = regmap_read(priv->regmap, CAP1106_REG_MANUFACTURER_ID, &val);	if (error)		return error;	if (val != CAP1106_MANUFACTURER_ID) {		dev_err(dev, "Manufacturer ID: Got 0x%02x, expected 0x%02x/n",			val, CAP1106_MANUFACTURER_ID);		return -ENODEV;	}	error = regmap_read(priv->regmap, CAP1106_REG_REVISION, &rev);	if (error < 0)		return error;	dev_info(dev, "CAP1106 detected, revision 0x%02x/n", rev);	i2c_set_clientdata(i2c_client, priv);	node = dev->of_node;	if (!of_property_read_u32(node, "microchip,sensor-gain", &gain32)) {		if (is_power_of_2(gain32) && gain32 <= 8)			gain = ilog2(gain32);		else			dev_err(dev, "Invalid sensor-gain value %d/n", gain32);	}	BUILD_BUG_ON(ARRAY_SIZE(keycodes) != ARRAY_SIZE(priv->keycodes));	/* Provide some useful defaults */	for (i = 0; i < ARRAY_SIZE(keycodes); i++)		keycodes[i] = KEY_A + i;	of_property_read_u32_array(node, "linux,keycodes",				   keycodes, ARRAY_SIZE(keycodes));	for (i = 0; i < ARRAY_SIZE(keycodes); i++)		priv->keycodes[i] = keycodes[i];	error = regmap_update_bits(priv->regmap, CAP1106_REG_MAIN_CONTROL,				   CAP1106_REG_MAIN_CONTROL_GAIN_MASK,				   gain << CAP1106_REG_MAIN_CONTROL_GAIN_SHIFT);	if (error)		return error;	/* Disable autorepeat. The Linux input system has its own handling. */	error = regmap_write(priv->regmap, CAP1106_REG_REPEAT_RATE, 0);	if (error)		return error;	priv->idev = devm_input_allocate_device(dev);	if (!priv->idev)		return -ENOMEM;	priv->idev->name = "CAP1106 capacitive touch sensor";	priv->idev->id.bustype = BUS_I2C;	priv->idev->evbit[0] = BIT_MASK(EV_KEY);	if (of_property_read_bool(node, "autorepeat"))		__set_bit(EV_REP, priv->idev->evbit);	for (i = 0; i < CAP1106_NUM_CHN; i++)		__set_bit(priv->keycodes[i], priv->idev->keybit);	__clear_bit(KEY_RESERVED, priv->idev->keybit);	priv->idev->keycode = priv->keycodes;	priv->idev->keycodesize = sizeof(priv->keycodes[0]);	priv->idev->keycodemax = ARRAY_SIZE(priv->keycodes);	priv->idev->id.vendor = CAP1106_MANUFACTURER_ID;	priv->idev->id.product = CAP1106_PRODUCT_ID;	priv->idev->id.version = rev;//.........这里部分代码省略.........