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

staticint ll_getxattr_common(struct inode *inode, const char *name,		       void *buffer, size_t size, __u64 valid){	struct ll_sb_info *sbi = ll_i2sbi(inode);	struct ptlrpc_request *req = NULL;	struct mdt_body *body;	int xattr_type, rc;	void *xdata;	struct obd_capa *oc;	struct rmtacl_ctl_entry *rce = NULL;	struct ll_inode_info *lli = ll_i2info(inode);	CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)/n",	       inode->i_ino, inode->i_generation, inode);	/* listxattr have slightly different behavior from of ext3:	 * without 'user_xattr' ext3 will list all xattr names but	 * filtered out "^user..*"; we list them all for simplicity.	 */	if (!name) {		xattr_type = XATTR_OTHER_T;		goto do_getxattr;	}	xattr_type = get_xattr_type(name);	rc = xattr_type_filter(sbi, xattr_type);	if (rc)		return rc;	/* b15587: ignore security.capability xattr for now */	if ((xattr_type == XATTR_SECURITY_T &&	    strcmp(name, "security.capability") == 0))		return -ENODATA;	/* LU-549:  Disable security.selinux when selinux is disabled */	if (xattr_type == XATTR_SECURITY_T && !selinux_is_enabled() &&	    strcmp(name, "security.selinux") == 0)		return -EOPNOTSUPP;#ifdef CONFIG_FS_POSIX_ACL	if (sbi->ll_flags & LL_SBI_RMT_CLIENT &&	    (xattr_type == XATTR_ACL_ACCESS_T ||	    xattr_type == XATTR_ACL_DEFAULT_T)) {		rce = rct_search(&sbi->ll_rct, current_pid());		if (rce == NULL ||		    (rce->rce_ops != RMT_LSETFACL &&		    rce->rce_ops != RMT_LGETFACL &&		    rce->rce_ops != RMT_RSETFACL &&		    rce->rce_ops != RMT_RGETFACL))			return -EOPNOTSUPP;	}	/* posix acl is under protection of LOOKUP lock. when calling to this,	 * we just have path resolution to the target inode, so we have great	 * chance that cached ACL is uptodate.	 */	if (xattr_type == XATTR_ACL_ACCESS_T &&	    !(sbi->ll_flags & LL_SBI_RMT_CLIENT)) {		struct posix_acl *acl;		spin_lock(&lli->lli_lock);		acl = posix_acl_dup(lli->lli_posix_acl);		spin_unlock(&lli->lli_lock);		if (!acl)			return -ENODATA;		rc = posix_acl_to_xattr(&init_user_ns, acl, buffer, size);		posix_acl_release(acl);		return rc;	}	if (xattr_type == XATTR_ACL_DEFAULT_T && !S_ISDIR(inode->i_mode))		return -ENODATA;#endifdo_getxattr:	if (sbi->ll_xattr_cache_enabled && xattr_type != XATTR_ACL_ACCESS_T) {		rc = ll_xattr_cache_get(inode, name, buffer, size, valid);		if (rc == -EAGAIN)			goto getxattr_nocache;		if (rc < 0)			goto out_xattr;		/* Add "system.posix_acl_access" to the list */		if (lli->lli_posix_acl != NULL && valid & OBD_MD_FLXATTRLS) {			if (size == 0) {				rc += sizeof(XATTR_NAME_ACL_ACCESS);			} else if (size - rc >= sizeof(XATTR_NAME_ACL_ACCESS)) {				memcpy(buffer + rc, XATTR_NAME_ACL_ACCESS,				       sizeof(XATTR_NAME_ACL_ACCESS));				rc += sizeof(XATTR_NAME_ACL_ACCESS);			} else {				rc = -ERANGE;				goto out_xattr;			}		}	} else {getxattr_nocache://.........这里部分代码省略.........

static int llog_process_thread(void *arg){	struct llog_process_info	*lpi = arg;	struct llog_handle		*loghandle = lpi->lpi_loghandle;	struct llog_log_hdr		*llh = loghandle->lgh_hdr;	struct llog_process_cat_data	*cd  = lpi->lpi_catdata;	char				*buf;	__u64				 cur_offset = LLOG_CHUNK_SIZE;	__u64				 last_offset;	int				 rc = 0, index = 1, last_index;	int				 saved_index = 0;	int				 last_called_index = 0;	LASSERT(llh);	OBD_ALLOC(buf, LLOG_CHUNK_SIZE);	if (!buf) {		lpi->lpi_rc = -ENOMEM;		return 0;	}	if (cd != NULL) {		last_called_index = cd->lpcd_first_idx;		index = cd->lpcd_first_idx + 1;	}	if (cd != NULL && cd->lpcd_last_idx)		last_index = cd->lpcd_last_idx;	else		last_index = LLOG_BITMAP_BYTES * 8 - 1;	while (rc == 0) {		struct llog_rec_hdr *rec;		/* skip records not set in bitmap */		while (index <= last_index &&		       !ext2_test_bit(index, llh->llh_bitmap))			++index;		LASSERT(index <= last_index + 1);		if (index == last_index + 1)			break;repeat:		CDEBUG(D_OTHER, "index: %d last_index %d/n",		       index, last_index);		/* get the buf with our target record; avoid old garbage */		memset(buf, 0, LLOG_CHUNK_SIZE);		last_offset = cur_offset;		rc = llog_next_block(lpi->lpi_env, loghandle, &saved_index,				     index, &cur_offset, buf, LLOG_CHUNK_SIZE);		if (rc)			GOTO(out, rc);		/* NB: when rec->lrh_len is accessed it is already swabbed		 * since it is used at the "end" of the loop and the rec		 * swabbing is done at the beginning of the loop. */		for (rec = (struct llog_rec_hdr *)buf;		     (char *)rec < buf + LLOG_CHUNK_SIZE;		     rec = (struct llog_rec_hdr *)((char *)rec + rec->lrh_len)){			CDEBUG(D_OTHER, "processing rec 0x%p type %#x/n",			       rec, rec->lrh_type);			if (LLOG_REC_HDR_NEEDS_SWABBING(rec))				lustre_swab_llog_rec(rec);			CDEBUG(D_OTHER, "after swabbing, type=%#x idx=%d/n",			       rec->lrh_type, rec->lrh_index);			if (rec->lrh_index == 0) {				/* probably another rec just got added? */				if (index <= loghandle->lgh_last_idx)					GOTO(repeat, rc = 0);				GOTO(out, rc = 0); /* no more records */			}			if (rec->lrh_len == 0 ||			    rec->lrh_len > LLOG_CHUNK_SIZE) {				CWARN("invalid length %d in llog record for "				      "index %d/%d/n", rec->lrh_len,				      rec->lrh_index, index);				GOTO(out, rc = -EINVAL);			}			if (rec->lrh_index < index) {				CDEBUG(D_OTHER, "skipping lrh_index %d/n",				       rec->lrh_index);				continue;			}			CDEBUG(D_OTHER,			       "lrh_index: %d lrh_len: %d (%d remains)/n",			       rec->lrh_index, rec->lrh_len,			       (int)(buf + LLOG_CHUNK_SIZE - (char *)rec));			loghandle->lgh_cur_idx = rec->lrh_index;			loghandle->lgh_cur_offset = (char *)rec - (char *)buf +						    last_offset;			/* if set, process the callback on this record */			if (ext2_test_bit(index, llh->llh_bitmap)) {//.........这里部分代码省略.........

/* * Server's incoming request callback */void request_in_callback(lnet_event_t *ev){	struct ptlrpc_cb_id		  *cbid = ev->md.user_ptr;	struct ptlrpc_request_buffer_desc *rqbd = cbid->cbid_arg;	struct ptlrpc_service_part	  *svcpt = rqbd->rqbd_svcpt;	struct ptlrpc_service	     *service = svcpt->scp_service;	struct ptlrpc_request	     *req;	LASSERT(ev->type == LNET_EVENT_PUT ||		ev->type == LNET_EVENT_UNLINK);	LASSERT((char *)ev->md.start >= rqbd->rqbd_buffer);	LASSERT((char *)ev->md.start + ev->offset + ev->mlength <=		rqbd->rqbd_buffer + service->srv_buf_size);	CDEBUG((ev->status == 0) ? D_NET : D_ERROR,	       "event type %d, status %d, service %s/n",	       ev->type, ev->status, service->srv_name);	if (ev->unlinked) {		/* If this is the last request message to fit in the		 * request buffer we can use the request object embedded in		 * rqbd.  Note that if we failed to allocate a request,		 * we'd have to re-post the rqbd, which we can't do in this		 * context. */		req = &rqbd->rqbd_req;		memset(req, 0, sizeof(*req));	} else {		LASSERT(ev->type == LNET_EVENT_PUT);		if (ev->status != 0) {			/* We moaned above already... */			return;		}		req = ptlrpc_request_cache_alloc(GFP_ATOMIC);		if (req == NULL) {			CERROR("Can't allocate incoming request descriptor: "			       "Dropping %s RPC from %s/n",			       service->srv_name,			       libcfs_id2str(ev->initiator));			return;		}	}	/* NB we ABSOLUTELY RELY on req being zeroed, so pointers are NULL,	 * flags are reset and scalars are zero.  We only set the message	 * size to non-zero if this was a successful receive. */	req->rq_xid = ev->match_bits;	req->rq_reqbuf = ev->md.start + ev->offset;	if (ev->type == LNET_EVENT_PUT && ev->status == 0)		req->rq_reqdata_len = ev->mlength;	do_gettimeofday(&req->rq_arrival_time);	req->rq_peer = ev->initiator;	req->rq_self = ev->target.nid;	req->rq_rqbd = rqbd;	req->rq_phase = RQ_PHASE_NEW;	spin_lock_init(&req->rq_lock);	INIT_LIST_HEAD(&req->rq_timed_list);	INIT_LIST_HEAD(&req->rq_exp_list);	atomic_set(&req->rq_refcount, 1);	if (ev->type == LNET_EVENT_PUT)		CDEBUG(D_INFO, "incoming [email
C++ CDTIME_T_TO_DOUBLE函数代码示例
C++ CDC_Device_USBTask函数代码示例