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

static struct apq8016_sbc_data *apq8016_sbc_parse_of(struct snd_soc_card *card){	struct device *dev = card->dev;	struct snd_soc_dai_link *link;	struct device_node *np, *codec, *cpu, *node  = dev->of_node;	struct apq8016_sbc_data *data;	int ret, num_links;	ret = snd_soc_of_parse_card_name(card, "qcom,model");	if (ret) {		dev_err(dev, "Error parsing card name: %d/n", ret);		return ERR_PTR(ret);	}	/* DAPM routes */	if (of_property_read_bool(node, "qcom,audio-routing")) {		ret = snd_soc_of_parse_audio_routing(card,					"qcom,audio-routing");		if (ret)			return ERR_PTR(ret);	}	/* Populate links */	num_links = of_get_child_count(node);	/* Allocate the private data and the DAI link array */	data = devm_kzalloc(dev, sizeof(*data) + sizeof(*link) * num_links,			    GFP_KERNEL);	if (!data)		return ERR_PTR(-ENOMEM);	card->dai_link	= &data->dai_link[0];	card->num_links	= num_links;	link = data->dai_link;	for_each_child_of_node(node, np) {		cpu = of_get_child_by_name(np, "cpu");		codec = of_get_child_by_name(np, "codec");		if (!cpu || !codec) {			dev_err(dev, "Can't find cpu/codec DT node/n");			return ERR_PTR(-EINVAL);		}		link->cpu_of_node = of_parse_phandle(cpu, "sound-dai", 0);		if (!link->cpu_of_node) {			dev_err(card->dev, "error getting cpu phandle/n");			return ERR_PTR(-EINVAL);		}		ret = snd_soc_of_get_dai_name(cpu, &link->cpu_dai_name);		if (ret) {			dev_err(card->dev, "error getting cpu dai name/n");			return ERR_PTR(ret);		}		ret = snd_soc_of_get_dai_link_codecs(dev, codec, link);		if (ret < 0) {			dev_err(card->dev, "error getting codec dai name/n");			return ERR_PTR(ret);		}		link->platform_of_node = link->cpu_of_node;		ret = of_property_read_string(np, "link-name", &link->name);		if (ret) {			dev_err(card->dev, "error getting codec dai_link name/n");			return ERR_PTR(ret);		}		link->stream_name = link->name;		link->init = apq8016_sbc_dai_init;		link++;	}

struct page *init_inode_metadata(struct inode *inode, struct inode *dir,			const struct qstr *name, struct page *dpage){	struct page *page;	int err;	if (is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) {		page = new_inode_page(inode);		if (IS_ERR(page))			return page;		if (S_ISDIR(inode->i_mode)) {			err = make_empty_dir(inode, dir, page);			if (err)				goto error;		}		err = f2fs_init_acl(inode, dir, page, dpage);		if (err)			goto put_error;		err = f2fs_init_security(inode, dir, name, page);		if (err)			goto put_error;	} else {		page = get_node_page(F2FS_I_SB(dir), inode->i_ino);		if (IS_ERR(page))			return page;		set_cold_node(inode, page);	}	if (name)		init_dent_inode(name, page);	/*	 * This file should be checkpointed during fsync.	 * We lost i_pino from now on.	 */	if (is_inode_flag_set(F2FS_I(inode), FI_INC_LINK)) {		file_lost_pino(inode);		/*		 * If link the tmpfile to alias through linkat path,		 * we should remove this inode from orphan list.		 */		if (inode->i_nlink == 0)			remove_orphan_inode(F2FS_I_SB(dir), inode->i_ino);		inc_nlink(inode);	}	return page;put_error:	f2fs_put_page(page, 1);error:	/* once the failed inode becomes a bad inode, i_mode is S_IFREG */	truncate_inode_pages(&inode->i_data, 0);	truncate_blocks(inode, 0, false);	remove_dirty_dir_inode(inode);	remove_inode_page(inode);	return ERR_PTR(err);}

/* Common file handle decoding for both parent and dentry */static struct dentry *vnlayer_decode_fh(    SUPER_T *sb,    struct fid *fh,    int len,                            /* counted in units of 4-bytes */    int fhtype,    int is_parent){    MDKI_FID_T *lfidp;    DENT_T *dp;    int error, fidlen;    SUPER_T *realsb;    unsigned realsb_hash;    fidlen = fhtype >> 1;    if (fidlen == 0) {        return ERR_PTR(-EINVAL);    }    if (len * 4 < MDKI_FID_LEN_WITH_HASH(fidlen)) {        MDKI_VFS_LOG(VFS_LOG_ESTALE,                      "%s: FH too small to be a MVFS FH/n",                      __FUNCTION__);        return ERR_PTR(-EINVAL);    }    lfidp = KMEM_ALLOC(MDKI_FID_ALLOC_LEN(fidlen), KM_SLEEP);    if (lfidp == NULL) {        return ERR_PTR(-ENOMEM);    }    if (is_parent) {        error = vnlayer_unpack_fh((__u32 *)fh, len, fhtype, fidlen,                                  NULL, lfidp);    } else {        error = vnlayer_unpack_fh((__u32 *)fh, len, fhtype, fidlen,                                  lfidp, NULL);    }    if (error == 0) {        realsb_hash = MDKI_FID_SB_HASH(fh, fidlen);        /*         * Search in the VOB mount list for the super_block we encoded.         * If the result is not NULL, the superblock was locked with         * lock_super and should be unlocked.         */        realsb = (SUPER_T *) mvfs_find_mount(vnlayer_eval_mount,                                             &realsb_hash);        if (realsb != NULL) {            /*             * It found a matching VOB mount to this hash, we will leave to             * vnlayer_get_dentry decides wether we can trust this FID,              * it should be able to smell any staleness.             */            dp = vnlayer_get_dentry(realsb, lfidp);            unlock_super(realsb);            if (IS_ERR(dp)) {                MDKI_VFS_LOG(VFS_LOG_ESTALE,                    "%s: pid %d vnlayer_get_dentry returned error %ld/n",                    __FUNCTION__, current->pid, PTR_ERR(dp));            }        } else {            dp = ERR_PTR(-EINVAL);            MDKI_VFS_LOG(VFS_LOG_ESTALE, "%s SB not found, hash=%08x/n",                         __FUNCTION__, realsb_hash);        }    } else {        dp = ERR_PTR(error);    }    KMEM_FREE(lfidp, MDKI_FID_ALLOC_LEN(fidlen));    return dp;}

struct q6v5_data __devinit *pil_q6v5_init(struct platform_device *pdev){	struct q6v5_data *drv;	struct resource *res;	struct pil_desc *desc;	int ret;#ifdef CONFIG_MACH_LGE	if (!strcmp(pdev->name, "mss"))		dev_info(&pdev->dev, "pil_q6v5_init, %s /n", pdev->name);#endif	drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL);	if (!drv)		return ERR_PTR(-ENOMEM);	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "qdsp6_base");	drv->reg_base = devm_request_and_ioremap(&pdev->dev, res);	if (!drv->reg_base)		return ERR_PTR(-ENOMEM);	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "halt_base");	drv->axi_halt_base = devm_ioremap(&pdev->dev, res->start,					  resource_size(res));	if (!drv->axi_halt_base)		return ERR_PTR(-ENOMEM);	desc = &drv->desc;	ret = of_property_read_string(pdev->dev.of_node, "qcom,firmware-name",				      &desc->name);	if (ret)		return ERR_PTR(ret);	drv->xo = devm_clk_get(&pdev->dev, "xo");	if (IS_ERR(drv->xo))		return ERR_CAST(drv->xo);	drv->vreg_cx = devm_regulator_get(&pdev->dev, "vdd_cx");	if (IS_ERR(drv->vreg_cx))		return ERR_CAST(drv->vreg_cx);	drv->vreg_pll = devm_regulator_get(&pdev->dev, "vdd_pll");	if (!IS_ERR(drv->vreg_pll)) {		int voltage;		ret = of_property_read_u32(pdev->dev.of_node, "qcom,vdd_pll",					   &voltage);		if (ret) {			dev_err(&pdev->dev, "Failed to find vdd_pll voltage./n");			return ERR_PTR(ret);		}		ret = regulator_set_voltage(drv->vreg_pll, voltage, voltage);		if (ret) {			dev_err(&pdev->dev, "Failed to request vdd_pll voltage./n");			return ERR_PTR(ret);		}		ret = regulator_set_optimum_mode(drv->vreg_pll, 10000);		if (ret < 0) {			dev_err(&pdev->dev, "Failed to set vdd_pll mode./n");			return ERR_PTR(ret);		}	} else {		 drv->vreg_pll = NULL;	}	desc->dev = &pdev->dev;	return drv;}

//.........这里部分代码省略.........{	struct crypto_cipher *cipher;	struct crypto_instance *inst = (void *)tfm->__crt_alg;	struct crypto_spawn *spawn = crypto_instance_ctx(inst);	struct priv *ctx = crypto_tfm_ctx(tfm);	u32 *flags = &tfm->crt_flags;	cipher = crypto_spawn_cipher(spawn);	if (IS_ERR(cipher))		return PTR_ERR(cipher);	if (crypto_cipher_blocksize(cipher) != XTS_BLOCK_SIZE) {		*flags |= CRYPTO_TFM_RES_BAD_BLOCK_LEN;		crypto_free_cipher(cipher);		return -EINVAL;	}	ctx->child = cipher;	cipher = crypto_spawn_cipher(spawn);	if (IS_ERR(cipher)) {		crypto_free_cipher(ctx->child);		return PTR_ERR(cipher);	}	/*                                                            */	if (crypto_cipher_blocksize(cipher) != XTS_BLOCK_SIZE) {		crypto_free_cipher(cipher);		crypto_free_cipher(ctx->child);		*flags |= CRYPTO_TFM_RES_BAD_BLOCK_LEN;		return -EINVAL;	}	ctx->tweak = cipher;	return 0;}static void exit_tfm(struct crypto_tfm *tfm){	struct priv *ctx = crypto_tfm_ctx(tfm);	crypto_free_cipher(ctx->child);	crypto_free_cipher(ctx->tweak);}static struct crypto_instance *alloc(struct rtattr **tb){	struct crypto_instance *inst;	struct crypto_alg *alg;	int err;	err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_BLKCIPHER);	if (err)		return ERR_PTR(err);	alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER,				  CRYPTO_ALG_TYPE_MASK);	if (IS_ERR(alg))		return ERR_CAST(alg);	inst = crypto_alloc_instance("xts", alg);	if (IS_ERR(inst))		goto out_put_alg;	inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER;	inst->alg.cra_priority = alg->cra_priority;	inst->alg.cra_blocksize = alg->cra_blocksize;	if (alg->cra_alignmask < 7)		inst->alg.cra_alignmask = 7;	else		inst->alg.cra_alignmask = alg->cra_alignmask;	inst->alg.cra_type = &crypto_blkcipher_type;	inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize;	inst->alg.cra_blkcipher.min_keysize =		2 * alg->cra_cipher.cia_min_keysize;	inst->alg.cra_blkcipher.max_keysize =		2 * alg->cra_cipher.cia_max_keysize;	inst->alg.cra_ctxsize = sizeof(struct priv);	inst->alg.cra_init = init_tfm;	inst->alg.cra_exit = exit_tfm;	inst->alg.cra_blkcipher.setkey = setkey;	inst->alg.cra_blkcipher.encrypt = encrypt;	inst->alg.cra_blkcipher.decrypt = decrypt;out_put_alg:	crypto_mod_put(alg);	return inst;}static void free(struct crypto_instance *inst){	crypto_drop_spawn(crypto_instance_ctx(inst));	kfree(inst);}

//.........这里部分代码省略.........    if (dentry->d_op && dentry->d_op->d_dname)    {        path = d_path(&pathPath, buffer, buflen);        if ( unlikely( IS_ERR(path) != 0 ) )        {            critical("talpa__d_path: d_path returned an error: %ld",PTR_ERR(path));            path = NULL;        }        if ( NULL != path )        {            return path;        }    }#endif /* TALPA_D_DNAME_DIRECT_DPATH */#   if defined TALPA_DPATH_SLES11    path = kernel_d_path(&pathPath, &rootPath, buffer, buflen, 0);#   elif defined TALPA_DPATH_PATH    path = kernel_d_path(&pathPath, &rootPath, buffer, buflen);#   elif defined TALPA_DPATH_SUSE103    path = kernel_d_path(dentry, vfsmnt, root, rootmnt, buffer, buflen, 0);#   else    path = kernel_d_path(dentry, vfsmnt, root, rootmnt, buffer, buflen);#   endif#else    /* Call our own version */    path = __talpa_d_path(dentry, vfsmnt, root, rootmnt, buffer, buflen);#endif#if defined HOLD_DCACHE_LOCK_WHILE_CALLING_D_PATH    spin_unlock(&dcache_lock);#endif    if ( unlikely( IS_ERR(path) != 0 ) )    {        critical("talpa__d_path: kernel__d_path returned an error: %ld",PTR_ERR(path));        path = NULL;    }    else if ( unlikely( NULL == path ) )    {#ifdef TALPA_D_DNAME_DIRECT_DPATH        /* only use this as a fall-back, it will only return the relative path from a chroot         * Use this in cases where kernel_d_path fails to return a valid path for bind mounts         * in newer kernel in a systemd environment */        path = d_path(&pathPath, buffer, buflen);        if ( unlikely( IS_ERR(path) != 0 ) )        {            critical("talpa__d_path: kernel_d_path returned an error: %ld",PTR_ERR(path));            path = NULL;        }        dbg("    dpath=%s",path);        if (dentry->d_op && dentry->d_op->d_dname)        {            err("dpath=%s - dentry has d_op and d_dname=%p",path,dentry->d_op->d_dname);        }#endif        if ( NULL == path )        {            if (!IS_ROOT(dentry) && d_unhashed(dentry)) {                dbg("talpa__d_path: kernel_d_path returned NULL for deleted file");                dbg("    basename=%s",dentry->d_name.name);            }            else            {                info("talpa__d_path: kernel_d_path returned NULL for non-deleted file");                info("    basename=%s",dentry->d_name.name);            }        }        else        {            if (!IS_ROOT(dentry) && d_unhashed(dentry))            {                dbg("    talpa__d_path: kernel_d_path returned NULL but d_path returned path %s for deleted file",path);            }            else            {#ifdef TALPA_MNT_NAMESPACE                if (NULL != getNamespaceInfo(vfsmnt) && (!S_ISDIR(dentry->d_inode->i_mode)))                {                    /* we're in a namespace/container, append '(namespace)' to the path */                    int pathlen=strlen(path);                    if (pathlen + 13 > buflen)                    {                        return ERR_PTR(-ENAMETOOLONG);                    }                    memmove(buffer, path, pathlen);                    path = buffer;                    memcpy(buffer + pathlen, " (namespace)", 13);                }#endif                /* the systemd / containers / bind mount case. */                dbg("    talpa__d_path: kernel_d_path returned NULL but d_path returned path %s for non-deleted file",path);            }        }    }    return path;}

/* * look up an entry in a directory */static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,				 struct nameidata *nd){	struct afs_vnode *vnode;	struct afs_fid fid;	struct inode *inode;	struct key *key;	int ret;	vnode = AFS_FS_I(dir);	_enter("{%x:%u},%p{%s},",	       vnode->fid.vid, vnode->fid.vnode, dentry, dentry->d_name.name);	ASSERTCMP(dentry->d_inode, ==, NULL);	if (dentry->d_name.len >= AFSNAMEMAX) {		_leave(" = -ENAMETOOLONG");		return ERR_PTR(-ENAMETOOLONG);	}	if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {		_leave(" = -ESTALE");		return ERR_PTR(-ESTALE);	}	key = afs_request_key(vnode->volume->cell);	if (IS_ERR(key)) {		_leave(" = %ld [key]", PTR_ERR(key));		return ERR_CAST(key);	}	ret = afs_validate(vnode, key);	if (ret < 0) {		key_put(key);		_leave(" = %d [val]", ret);		return ERR_PTR(ret);	}	ret = afs_do_lookup(dir, dentry, &fid, key);	if (ret < 0) {		inode = afs_try_auto_mntpt(ret, dentry, dir, key, &fid);		if (!IS_ERR(inode)) {			key_put(key);			goto success;		}		ret = PTR_ERR(inode);		key_put(key);		if (ret == -ENOENT) {			d_add(dentry, NULL);			_leave(" = NULL [negative]");			return NULL;		}		_leave(" = %d [do]", ret);		return ERR_PTR(ret);	}	dentry->d_fsdata = (void *)(unsigned long) vnode->status.data_version;	/* instantiate the dentry */	inode = afs_iget(dir->i_sb, key, &fid, NULL, NULL);	key_put(key);	if (IS_ERR(inode)) {		_leave(" = %ld", PTR_ERR(inode));		return ERR_CAST(inode);	}success:	d_add(dentry, inode);	_leave(" = 0 { vn=%u u=%u } -> { ino=%lu v=%u }",	       fid.vnode,	       fid.unique,	       dentry->d_inode->i_ino,	       dentry->d_inode->i_generation);	return NULL;}

//.........这里部分代码省略.........			LOGW("%s: read %s failed, %[email
C++ ERR_TRACE函数代码示例
C++ ERR_PRINTS函数代码示例