1 /* 2 * include/net/9p/9p.h 3 * 4 * 9P protocol definitions. 5 * 6 * Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net> 7 * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com> 8 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov> 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License version 2 12 * as published by the Free Software Foundation. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to: 21 * Free Software Foundation 22 * 51 Franklin Street, Fifth Floor 23 * Boston, MA 02111-1301 USA 24 * 25 */ 26 27 #ifndef NET_9P_H 28 #define NET_9P_H 29 30 /** 31 * enum p9_debug_flags - bits for mount time debug parameter 32 * @P9_DEBUG_ERROR: more verbose error messages including original error string 33 * @P9_DEBUG_9P: 9P protocol tracing 34 * @P9_DEBUG_VFS: VFS API tracing 35 * @P9_DEBUG_CONV: protocol conversion tracing 36 * @P9_DEBUG_MUX: trace management of concurrent transactions 37 * @P9_DEBUG_TRANS: transport tracing 38 * @P9_DEBUG_SLABS: memory management tracing 39 * @P9_DEBUG_FCALL: verbose dump of protocol messages 40 * @P9_DEBUG_FID: fid allocation/deallocation tracking 41 * @P9_DEBUG_PKT: packet marshalling/unmarshalling 42 * @P9_DEBUG_FSC: FS-cache tracing 43 * 44 * These flags are passed at mount time to turn on various levels of 45 * verbosity and tracing which will be output to the system logs. 46 */ 47 48 enum p9_debug_flags { 49 P9_DEBUG_ERROR = (1<<0), 50 P9_DEBUG_9P = (1<<2), 51 P9_DEBUG_VFS = (1<<3), 52 P9_DEBUG_CONV = (1<<4), 53 P9_DEBUG_MUX = (1<<5), 54 P9_DEBUG_TRANS = (1<<6), 55 P9_DEBUG_SLABS = (1<<7), 56 P9_DEBUG_FCALL = (1<<8), 57 P9_DEBUG_FID = (1<<9), 58 P9_DEBUG_PKT = (1<<10), 59 P9_DEBUG_FSC = (1<<11), 60 }; 61 62 #ifdef CONFIG_NET_9P_DEBUG 63 extern unsigned int p9_debug_level; 64 65 #define P9_DPRINTK(level, format, arg...) \ 66 do { \ 67 if ((p9_debug_level & level) == level) {\ 68 if (level == P9_DEBUG_9P) \ 69 printk(KERN_NOTICE "(%8.8d) " \ 70 format , task_pid_nr(current) , ## arg); \ 71 else \ 72 printk(KERN_NOTICE "-- %s (%d): " \ 73 format , __func__, task_pid_nr(current) , ## arg); \ 74 } \ 75 } while (0) 76 77 #else 78 #define P9_DPRINTK(level, format, arg...) do { } while (0) 79 #endif 80 81 #define P9_EPRINTK(level, format, arg...) \ 82 do { \ 83 printk(level "9p: %s (%d): " \ 84 format , __func__, task_pid_nr(current), ## arg); \ 85 } while (0) 86 87 /** 88 * enum p9_msg_t - 9P message types 89 * @P9_TLERROR: not used 90 * @P9_RLERROR: response for any failed request for 9P2000.L 91 * @P9_TSTATFS: file system status request 92 * @P9_RSTATFS: file system status response 93 * @P9_TSYMLINK: make symlink request 94 * @P9_RSYMLINK: make symlink response 95 * @P9_TMKNOD: create a special file object request 96 * @P9_RMKNOD: create a special file object response 97 * @P9_TLCREATE: prepare a handle for I/O on an new file for 9P2000.L 98 * @P9_RLCREATE: response with file access information for 9P2000.L 99 * @P9_TRENAME: rename request 100 * @P9_RRENAME: rename response 101 * @P9_TMKDIR: create a directory request 102 * @P9_RMKDIR: create a directory response 103 * @P9_TVERSION: version handshake request 104 * @P9_RVERSION: version handshake response 105 * @P9_TAUTH: request to establish authentication channel 106 * @P9_RAUTH: response with authentication information 107 * @P9_TATTACH: establish user access to file service 108 * @P9_RATTACH: response with top level handle to file hierarchy 109 * @P9_TERROR: not used 110 * @P9_RERROR: response for any failed request 111 * @P9_TFLUSH: request to abort a previous request 112 * @P9_RFLUSH: response when previous request has been cancelled 113 * @P9_TWALK: descend a directory hierarchy 114 * @P9_RWALK: response with new handle for position within hierarchy 115 * @P9_TOPEN: prepare a handle for I/O on an existing file 116 * @P9_ROPEN: response with file access information 117 * @P9_TCREATE: prepare a handle for I/O on a new file 118 * @P9_RCREATE: response with file access information 119 * @P9_TREAD: request to transfer data from a file or directory 120 * @P9_RREAD: response with data requested 121 * @P9_TWRITE: reuqest to transfer data to a file 122 * @P9_RWRITE: response with out much data was transfered to file 123 * @P9_TCLUNK: forget about a handle to an entity within the file system 124 * @P9_RCLUNK: response when server has forgotten about the handle 125 * @P9_TREMOVE: request to remove an entity from the hierarchy 126 * @P9_RREMOVE: response when server has removed the entity 127 * @P9_TSTAT: request file entity attributes 128 * @P9_RSTAT: response with file entity attributes 129 * @P9_TWSTAT: request to update file entity attributes 130 * @P9_RWSTAT: response when file entity attributes are updated 131 * 132 * There are 14 basic operations in 9P2000, paired as 133 * requests and responses. The one special case is ERROR 134 * as there is no @P9_TERROR request for clients to transmit to 135 * the server, but the server may respond to any other request 136 * with an @P9_RERROR. 137 * 138 * See Also: http://plan9.bell-labs.com/sys/man/5/INDEX.html 139 */ 140 141 enum p9_msg_t { 142 P9_TSYNCFS = 0, 143 P9_RSYNCFS, 144 P9_TLERROR = 6, 145 P9_RLERROR, 146 P9_TSTATFS = 8, 147 P9_RSTATFS, 148 P9_TLOPEN = 12, 149 P9_RLOPEN, 150 P9_TLCREATE = 14, 151 P9_RLCREATE, 152 P9_TSYMLINK = 16, 153 P9_RSYMLINK, 154 P9_TMKNOD = 18, 155 P9_RMKNOD, 156 P9_TRENAME = 20, 157 P9_RRENAME, 158 P9_TREADLINK = 22, 159 P9_RREADLINK, 160 P9_TGETATTR = 24, 161 P9_RGETATTR, 162 P9_TSETATTR = 26, 163 P9_RSETATTR, 164 P9_TXATTRWALK = 30, 165 P9_RXATTRWALK, 166 P9_TXATTRCREATE = 32, 167 P9_RXATTRCREATE, 168 P9_TREADDIR = 40, 169 P9_RREADDIR, 170 P9_TFSYNC = 50, 171 P9_RFSYNC, 172 P9_TLOCK = 52, 173 P9_RLOCK, 174 P9_TGETLOCK = 54, 175 P9_RGETLOCK, 176 P9_TLINK = 70, 177 P9_RLINK, 178 P9_TMKDIR = 72, 179 P9_RMKDIR, 180 P9_TVERSION = 100, 181 P9_RVERSION, 182 P9_TAUTH = 102, 183 P9_RAUTH, 184 P9_TATTACH = 104, 185 P9_RATTACH, 186 P9_TERROR = 106, 187 P9_RERROR, 188 P9_TFLUSH = 108, 189 P9_RFLUSH, 190 P9_TWALK = 110, 191 P9_RWALK, 192 P9_TOPEN = 112, 193 P9_ROPEN, 194 P9_TCREATE = 114, 195 P9_RCREATE, 196 P9_TREAD = 116, 197 P9_RREAD, 198 P9_TWRITE = 118, 199 P9_RWRITE, 200 P9_TCLUNK = 120, 201 P9_RCLUNK, 202 P9_TREMOVE = 122, 203 P9_RREMOVE, 204 P9_TSTAT = 124, 205 P9_RSTAT, 206 P9_TWSTAT = 126, 207 P9_RWSTAT, 208 }; 209 210 /** 211 * enum p9_open_mode_t - 9P open modes 212 * @P9_OREAD: open file for reading only 213 * @P9_OWRITE: open file for writing only 214 * @P9_ORDWR: open file for reading or writing 215 * @P9_OEXEC: open file for execution 216 * @P9_OTRUNC: truncate file to zero-length before opening it 217 * @P9_OREXEC: close the file when an exec(2) system call is made 218 * @P9_ORCLOSE: remove the file when the file is closed 219 * @P9_OAPPEND: open the file and seek to the end 220 * @P9_OEXCL: only create a file, do not open it 221 * 222 * 9P open modes differ slightly from Posix standard modes. 223 * In particular, there are extra modes which specify different 224 * semantic behaviors than may be available on standard Posix 225 * systems. For example, @P9_OREXEC and @P9_ORCLOSE are modes that 226 * most likely will not be issued from the Linux VFS client, but may 227 * be supported by servers. 228 * 229 * See Also: http://plan9.bell-labs.com/magic/man2html/2/open 230 */ 231 232 enum p9_open_mode_t { 233 P9_OREAD = 0x00, 234 P9_OWRITE = 0x01, 235 P9_ORDWR = 0x02, 236 P9_OEXEC = 0x03, 237 P9_OTRUNC = 0x10, 238 P9_OREXEC = 0x20, 239 P9_ORCLOSE = 0x40, 240 P9_OAPPEND = 0x80, 241 P9_OEXCL = 0x1000, 242 }; 243 244 /** 245 * enum p9_perm_t - 9P permissions 246 * @P9_DMDIR: mode bite for directories 247 * @P9_DMAPPEND: mode bit for is append-only 248 * @P9_DMEXCL: mode bit for excluse use (only one open handle allowed) 249 * @P9_DMMOUNT: mode bite for mount points 250 * @P9_DMAUTH: mode bit for authentication file 251 * @P9_DMTMP: mode bit for non-backed-up files 252 * @P9_DMSYMLINK: mode bit for symbolic links (9P2000.u) 253 * @P9_DMLINK: mode bit for hard-link (9P2000.u) 254 * @P9_DMDEVICE: mode bit for device files (9P2000.u) 255 * @P9_DMNAMEDPIPE: mode bit for named pipe (9P2000.u) 256 * @P9_DMSOCKET: mode bit for socket (9P2000.u) 257 * @P9_DMSETUID: mode bit for setuid (9P2000.u) 258 * @P9_DMSETGID: mode bit for setgid (9P2000.u) 259 * @P9_DMSETVTX: mode bit for sticky bit (9P2000.u) 260 * 261 * 9P permissions differ slightly from Posix standard modes. 262 * 263 * See Also: http://plan9.bell-labs.com/magic/man2html/2/stat 264 */ 265 enum p9_perm_t { 266 P9_DMDIR = 0x80000000, 267 P9_DMAPPEND = 0x40000000, 268 P9_DMEXCL = 0x20000000, 269 P9_DMMOUNT = 0x10000000, 270 P9_DMAUTH = 0x08000000, 271 P9_DMTMP = 0x04000000, 272 /* 9P2000.u extensions */ 273 P9_DMSYMLINK = 0x02000000, 274 P9_DMLINK = 0x01000000, 275 P9_DMDEVICE = 0x00800000, 276 P9_DMNAMEDPIPE = 0x00200000, 277 P9_DMSOCKET = 0x00100000, 278 P9_DMSETUID = 0x00080000, 279 P9_DMSETGID = 0x00040000, 280 P9_DMSETVTX = 0x00010000, 281 }; 282 283 /** 284 * enum p9_qid_t - QID types 285 * @P9_QTDIR: directory 286 * @P9_QTAPPEND: append-only 287 * @P9_QTEXCL: excluse use (only one open handle allowed) 288 * @P9_QTMOUNT: mount points 289 * @P9_QTAUTH: authentication file 290 * @P9_QTTMP: non-backed-up files 291 * @P9_QTSYMLINK: symbolic links (9P2000.u) 292 * @P9_QTLINK: hard-link (9P2000.u) 293 * @P9_QTFILE: normal files 294 * 295 * QID types are a subset of permissions - they are primarily 296 * used to differentiate semantics for a file system entity via 297 * a jump-table. Their value is also the most signifigant 16 bits 298 * of the permission_t 299 * 300 * See Also: http://plan9.bell-labs.com/magic/man2html/2/stat 301 */ 302 enum p9_qid_t { 303 P9_QTDIR = 0x80, 304 P9_QTAPPEND = 0x40, 305 P9_QTEXCL = 0x20, 306 P9_QTMOUNT = 0x10, 307 P9_QTAUTH = 0x08, 308 P9_QTTMP = 0x04, 309 P9_QTSYMLINK = 0x02, 310 P9_QTLINK = 0x01, 311 P9_QTFILE = 0x00, 312 }; 313 314 /* 9P Magic Numbers */ 315 #define P9_NOTAG (u16)(~0) 316 #define P9_NOFID (u32)(~0) 317 #define P9_MAXWELEM 16 318 319 /* ample room for Twrite/Rread header */ 320 #define P9_IOHDRSZ 24 321 322 /* Room for readdir header */ 323 #define P9_READDIRHDRSZ 24 324 325 /** 326 * struct p9_str - length prefixed string type 327 * @len: length of the string 328 * @str: the string 329 * 330 * The protocol uses length prefixed strings for all 331 * string data, so we replicate that for our internal 332 * string members. 333 */ 334 335 struct p9_str { 336 u16 len; 337 char *str; 338 }; 339 340 /** 341 * struct p9_qid - file system entity information 342 * @type: 8-bit type &p9_qid_t 343 * @version: 16-bit monotonically incrementing version number 344 * @path: 64-bit per-server-unique ID for a file system element 345 * 346 * qids are identifiers used by 9P servers to track file system 347 * entities. The type is used to differentiate semantics for operations 348 * on the entity (ie. read means something different on a directory than 349 * on a file). The path provides a server unique index for an entity 350 * (roughly analogous to an inode number), while the version is updated 351 * every time a file is modified and can be used to maintain cache 352 * coherency between clients and serves. 353 * Servers will often differentiate purely synthetic entities by setting 354 * their version to 0, signaling that they should never be cached and 355 * should be accessed synchronously. 356 * 357 * See Also://plan9.bell-labs.com/magic/man2html/2/stat 358 */ 359 360 struct p9_qid { 361 u8 type; 362 u32 version; 363 u64 path; 364 }; 365 366 /** 367 * struct p9_stat - file system metadata information 368 * @size: length prefix for this stat structure instance 369 * @type: the type of the server (equivilent to a major number) 370 * @dev: the sub-type of the server (equivilent to a minor number) 371 * @qid: unique id from the server of type &p9_qid 372 * @mode: Plan 9 format permissions of type &p9_perm_t 373 * @atime: Last access/read time 374 * @mtime: Last modify/write time 375 * @length: file length 376 * @name: last element of path (aka filename) in type &p9_str 377 * @uid: owner name in type &p9_str 378 * @gid: group owner in type &p9_str 379 * @muid: last modifier in type &p9_str 380 * @extension: area used to encode extended UNIX support in type &p9_str 381 * @n_uid: numeric user id of owner (part of 9p2000.u extension) 382 * @n_gid: numeric group id (part of 9p2000.u extension) 383 * @n_muid: numeric user id of laster modifier (part of 9p2000.u extension) 384 * 385 * See Also: http://plan9.bell-labs.com/magic/man2html/2/stat 386 */ 387 388 struct p9_wstat { 389 u16 size; 390 u16 type; 391 u32 dev; 392 struct p9_qid qid; 393 u32 mode; 394 u32 atime; 395 u32 mtime; 396 u64 length; 397 char *name; 398 char *uid; 399 char *gid; 400 char *muid; 401 char *extension; /* 9p2000.u extensions */ 402 u32 n_uid; /* 9p2000.u extensions */ 403 u32 n_gid; /* 9p2000.u extensions */ 404 u32 n_muid; /* 9p2000.u extensions */ 405 }; 406 407 struct p9_stat_dotl { 408 u64 st_result_mask; 409 struct p9_qid qid; 410 u32 st_mode; 411 u32 st_uid; 412 u32 st_gid; 413 u64 st_nlink; 414 u64 st_rdev; 415 u64 st_size; 416 u64 st_blksize; 417 u64 st_blocks; 418 u64 st_atime_sec; 419 u64 st_atime_nsec; 420 u64 st_mtime_sec; 421 u64 st_mtime_nsec; 422 u64 st_ctime_sec; 423 u64 st_ctime_nsec; 424 u64 st_btime_sec; 425 u64 st_btime_nsec; 426 u64 st_gen; 427 u64 st_data_version; 428 }; 429 430 #define P9_STATS_MODE 0x00000001ULL 431 #define P9_STATS_NLINK 0x00000002ULL 432 #define P9_STATS_UID 0x00000004ULL 433 #define P9_STATS_GID 0x00000008ULL 434 #define P9_STATS_RDEV 0x00000010ULL 435 #define P9_STATS_ATIME 0x00000020ULL 436 #define P9_STATS_MTIME 0x00000040ULL 437 #define P9_STATS_CTIME 0x00000080ULL 438 #define P9_STATS_INO 0x00000100ULL 439 #define P9_STATS_SIZE 0x00000200ULL 440 #define P9_STATS_BLOCKS 0x00000400ULL 441 442 #define P9_STATS_BTIME 0x00000800ULL 443 #define P9_STATS_GEN 0x00001000ULL 444 #define P9_STATS_DATA_VERSION 0x00002000ULL 445 446 #define P9_STATS_BASIC 0x000007ffULL /* Mask for fields up to BLOCKS */ 447 #define P9_STATS_ALL 0x00003fffULL /* Mask for All fields above */ 448 449 /** 450 * struct p9_iattr_dotl - P9 inode attribute for setattr 451 * @valid: bitfield specifying which fields are valid 452 * same as in struct iattr 453 * @mode: File permission bits 454 * @uid: user id of owner 455 * @gid: group id 456 * @size: File size 457 * @atime_sec: Last access time, seconds 458 * @atime_nsec: Last access time, nanoseconds 459 * @mtime_sec: Last modification time, seconds 460 * @mtime_nsec: Last modification time, nanoseconds 461 */ 462 463 struct p9_iattr_dotl { 464 u32 valid; 465 u32 mode; 466 u32 uid; 467 u32 gid; 468 u64 size; 469 u64 atime_sec; 470 u64 atime_nsec; 471 u64 mtime_sec; 472 u64 mtime_nsec; 473 }; 474 475 #define P9_LOCK_SUCCESS 0 476 #define P9_LOCK_BLOCKED 1 477 #define P9_LOCK_ERROR 2 478 #define P9_LOCK_GRACE 3 479 480 #define P9_LOCK_FLAGS_BLOCK 1 481 #define P9_LOCK_FLAGS_RECLAIM 2 482 483 /* struct p9_flock: POSIX lock structure 484 * @type - type of lock 485 * @flags - lock flags 486 * @start - starting offset of the lock 487 * @length - number of bytes 488 * @proc_id - process id which wants to take lock 489 * @client_id - client id 490 */ 491 492 struct p9_flock { 493 u8 type; 494 u32 flags; 495 u64 start; 496 u64 length; 497 u32 proc_id; 498 char *client_id; 499 }; 500 501 /* struct p9_getlock: getlock structure 502 * @type - type of lock 503 * @start - starting offset of the lock 504 * @length - number of bytes 505 * @proc_id - process id which wants to take lock 506 * @client_id - client id 507 */ 508 509 struct p9_getlock { 510 u8 type; 511 u64 start; 512 u64 length; 513 u32 proc_id; 514 char *client_id; 515 }; 516 517 /* Structures for Protocol Operations */ 518 struct p9_tstatfs { 519 u32 fid; 520 }; 521 522 struct p9_rstatfs { 523 u32 type; 524 u32 bsize; 525 u64 blocks; 526 u64 bfree; 527 u64 bavail; 528 u64 files; 529 u64 ffree; 530 u64 fsid; 531 u32 namelen; 532 }; 533 534 struct p9_trename { 535 u32 fid; 536 u32 newdirfid; 537 struct p9_str name; 538 }; 539 540 struct p9_rrename { 541 }; 542 543 struct p9_tversion { 544 u32 msize; 545 struct p9_str version; 546 }; 547 548 struct p9_rversion { 549 u32 msize; 550 struct p9_str version; 551 }; 552 553 struct p9_tauth { 554 u32 afid; 555 struct p9_str uname; 556 struct p9_str aname; 557 u32 n_uname; /* 9P2000.u extensions */ 558 }; 559 560 struct p9_rauth { 561 struct p9_qid qid; 562 }; 563 564 struct p9_rerror { 565 struct p9_str error; 566 u32 errno; /* 9p2000.u extension */ 567 }; 568 569 struct p9_tflush { 570 u16 oldtag; 571 }; 572 573 struct p9_rflush { 574 }; 575 576 struct p9_tattach { 577 u32 fid; 578 u32 afid; 579 struct p9_str uname; 580 struct p9_str aname; 581 u32 n_uname; /* 9P2000.u extensions */ 582 }; 583 584 struct p9_rattach { 585 struct p9_qid qid; 586 }; 587 588 struct p9_twalk { 589 u32 fid; 590 u32 newfid; 591 u16 nwname; 592 struct p9_str wnames[16]; 593 }; 594 595 struct p9_rwalk { 596 u16 nwqid; 597 struct p9_qid wqids[16]; 598 }; 599 600 struct p9_topen { 601 u32 fid; 602 u8 mode; 603 }; 604 605 struct p9_ropen { 606 struct p9_qid qid; 607 u32 iounit; 608 }; 609 610 struct p9_tcreate { 611 u32 fid; 612 struct p9_str name; 613 u32 perm; 614 u8 mode; 615 struct p9_str extension; 616 }; 617 618 struct p9_rcreate { 619 struct p9_qid qid; 620 u32 iounit; 621 }; 622 623 struct p9_tread { 624 u32 fid; 625 u64 offset; 626 u32 count; 627 }; 628 629 struct p9_rread { 630 u32 count; 631 u8 *data; 632 }; 633 634 struct p9_twrite { 635 u32 fid; 636 u64 offset; 637 u32 count; 638 u8 *data; 639 }; 640 641 struct p9_rwrite { 642 u32 count; 643 }; 644 645 struct p9_treaddir { 646 u32 fid; 647 u64 offset; 648 u32 count; 649 }; 650 651 struct p9_rreaddir { 652 u32 count; 653 u8 *data; 654 }; 655 656 657 struct p9_tclunk { 658 u32 fid; 659 }; 660 661 struct p9_rclunk { 662 }; 663 664 struct p9_tremove { 665 u32 fid; 666 }; 667 668 struct p9_rremove { 669 }; 670 671 struct p9_tstat { 672 u32 fid; 673 }; 674 675 struct p9_rstat { 676 struct p9_wstat stat; 677 }; 678 679 struct p9_twstat { 680 u32 fid; 681 struct p9_wstat stat; 682 }; 683 684 struct p9_rwstat { 685 }; 686 687 /** 688 * struct p9_fcall - primary packet structure 689 * @size: prefixed length of the structure 690 * @id: protocol operating identifier of type &p9_msg_t 691 * @tag: transaction id of the request 692 * @offset: used by marshalling routines to track currentposition in buffer 693 * @capacity: used by marshalling routines to track total malloc'd capacity 694 * @pubuf: Payload user buffer given by the caller 695 * @pubuf: Payload kernel buffer given by the caller 696 * @pbuf_size: pubuf/pkbuf(only one will be !NULL) size to be read/write. 697 * @private: For transport layer's use. 698 * @sdata: payload 699 * 700 * &p9_fcall represents the structure for all 9P RPC 701 * transactions. Requests are packaged into fcalls, and reponses 702 * must be extracted from them. 703 * 704 * See Also: http://plan9.bell-labs.com/magic/man2html/2/fcall 705 */ 706 707 struct p9_fcall { 708 u32 size; 709 u8 id; 710 u16 tag; 711 712 size_t offset; 713 size_t capacity; 714 char __user *pubuf; 715 char *pkbuf; 716 size_t pbuf_size; 717 void *private; 718 719 uint8_t *sdata; 720 }; 721 722 struct p9_idpool; 723 724 int p9_errstr2errno(char *errstr, int len); 725 726 struct p9_idpool *p9_idpool_create(void); 727 void p9_idpool_destroy(struct p9_idpool *); 728 int p9_idpool_get(struct p9_idpool *p); 729 void p9_idpool_put(int id, struct p9_idpool *p); 730 int p9_idpool_check(int id, struct p9_idpool *p); 731 732 int p9_error_init(void); 733 int p9_errstr2errno(char *, int); 734 int p9_trans_fd_init(void); 735 void p9_trans_fd_exit(void); 736 #endif /* NET_9P_H */ 737