open.c 25 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121
  1. /*
  2. * linux/fs/open.c
  3. *
  4. * Copyright (C) 1991, 1992 Linus Torvalds
  5. */
  6. #include <linux/string.h>
  7. #include <linux/mm.h>
  8. #include <linux/file.h>
  9. #include <linux/smp_lock.h>
  10. #include <linux/quotaops.h>
  11. #include <linux/fsnotify.h>
  12. #include <linux/module.h>
  13. #include <linux/slab.h>
  14. #include <linux/tty.h>
  15. #include <linux/namei.h>
  16. #include <linux/backing-dev.h>
  17. #include <linux/capability.h>
  18. #include <linux/security.h>
  19. #include <linux/mount.h>
  20. #include <linux/vfs.h>
  21. #include <linux/fcntl.h>
  22. #include <asm/uaccess.h>
  23. #include <linux/fs.h>
  24. #include <linux/personality.h>
  25. #include <linux/pagemap.h>
  26. #include <linux/syscalls.h>
  27. #include <linux/rcupdate.h>
  28. #include <linux/audit.h>
  29. int vfs_statfs(struct dentry *dentry, struct kstatfs *buf)
  30. {
  31. int retval = -ENODEV;
  32. if (dentry) {
  33. retval = -ENOSYS;
  34. if (dentry->d_sb->s_op->statfs) {
  35. memset(buf, 0, sizeof(*buf));
  36. retval = security_sb_statfs(dentry);
  37. if (retval)
  38. return retval;
  39. retval = dentry->d_sb->s_op->statfs(dentry, buf);
  40. if (retval == 0 && buf->f_frsize == 0)
  41. buf->f_frsize = buf->f_bsize;
  42. }
  43. }
  44. return retval;
  45. }
  46. EXPORT_SYMBOL(vfs_statfs);
  47. static int vfs_statfs_native(struct dentry *dentry, struct statfs *buf)
  48. {
  49. struct kstatfs st;
  50. int retval;
  51. retval = vfs_statfs(dentry, &st);
  52. if (retval)
  53. return retval;
  54. if (sizeof(*buf) == sizeof(st))
  55. memcpy(buf, &st, sizeof(st));
  56. else {
  57. if (sizeof buf->f_blocks == 4) {
  58. if ((st.f_blocks | st.f_bfree | st.f_bavail) &
  59. 0xffffffff00000000ULL)
  60. return -EOVERFLOW;
  61. /*
  62. * f_files and f_ffree may be -1; it's okay to stuff
  63. * that into 32 bits
  64. */
  65. if (st.f_files != -1 &&
  66. (st.f_files & 0xffffffff00000000ULL))
  67. return -EOVERFLOW;
  68. if (st.f_ffree != -1 &&
  69. (st.f_ffree & 0xffffffff00000000ULL))
  70. return -EOVERFLOW;
  71. }
  72. buf->f_type = st.f_type;
  73. buf->f_bsize = st.f_bsize;
  74. buf->f_blocks = st.f_blocks;
  75. buf->f_bfree = st.f_bfree;
  76. buf->f_bavail = st.f_bavail;
  77. buf->f_files = st.f_files;
  78. buf->f_ffree = st.f_ffree;
  79. buf->f_fsid = st.f_fsid;
  80. buf->f_namelen = st.f_namelen;
  81. buf->f_frsize = st.f_frsize;
  82. memset(buf->f_spare, 0, sizeof(buf->f_spare));
  83. }
  84. return 0;
  85. }
  86. static int vfs_statfs64(struct dentry *dentry, struct statfs64 *buf)
  87. {
  88. struct kstatfs st;
  89. int retval;
  90. retval = vfs_statfs(dentry, &st);
  91. if (retval)
  92. return retval;
  93. if (sizeof(*buf) == sizeof(st))
  94. memcpy(buf, &st, sizeof(st));
  95. else {
  96. buf->f_type = st.f_type;
  97. buf->f_bsize = st.f_bsize;
  98. buf->f_blocks = st.f_blocks;
  99. buf->f_bfree = st.f_bfree;
  100. buf->f_bavail = st.f_bavail;
  101. buf->f_files = st.f_files;
  102. buf->f_ffree = st.f_ffree;
  103. buf->f_fsid = st.f_fsid;
  104. buf->f_namelen = st.f_namelen;
  105. buf->f_frsize = st.f_frsize;
  106. memset(buf->f_spare, 0, sizeof(buf->f_spare));
  107. }
  108. return 0;
  109. }
  110. asmlinkage long sys_statfs(const char __user * path, struct statfs __user * buf)
  111. {
  112. struct nameidata nd;
  113. int error;
  114. error = user_path_walk(path, &nd);
  115. if (!error) {
  116. struct statfs tmp;
  117. error = vfs_statfs_native(nd.dentry, &tmp);
  118. if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
  119. error = -EFAULT;
  120. path_release(&nd);
  121. }
  122. return error;
  123. }
  124. asmlinkage long sys_statfs64(const char __user *path, size_t sz, struct statfs64 __user *buf)
  125. {
  126. struct nameidata nd;
  127. long error;
  128. if (sz != sizeof(*buf))
  129. return -EINVAL;
  130. error = user_path_walk(path, &nd);
  131. if (!error) {
  132. struct statfs64 tmp;
  133. error = vfs_statfs64(nd.dentry, &tmp);
  134. if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
  135. error = -EFAULT;
  136. path_release(&nd);
  137. }
  138. return error;
  139. }
  140. asmlinkage long sys_fstatfs(unsigned int fd, struct statfs __user * buf)
  141. {
  142. struct file * file;
  143. struct statfs tmp;
  144. int error;
  145. error = -EBADF;
  146. file = fget(fd);
  147. if (!file)
  148. goto out;
  149. error = vfs_statfs_native(file->f_path.dentry, &tmp);
  150. if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
  151. error = -EFAULT;
  152. fput(file);
  153. out:
  154. return error;
  155. }
  156. asmlinkage long sys_fstatfs64(unsigned int fd, size_t sz, struct statfs64 __user *buf)
  157. {
  158. struct file * file;
  159. struct statfs64 tmp;
  160. int error;
  161. if (sz != sizeof(*buf))
  162. return -EINVAL;
  163. error = -EBADF;
  164. file = fget(fd);
  165. if (!file)
  166. goto out;
  167. error = vfs_statfs64(file->f_path.dentry, &tmp);
  168. if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
  169. error = -EFAULT;
  170. fput(file);
  171. out:
  172. return error;
  173. }
  174. int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs,
  175. struct file *filp)
  176. {
  177. int err;
  178. struct iattr newattrs;
  179. /* Not pretty: "inode->i_size" shouldn't really be signed. But it is. */
  180. if (length < 0)
  181. return -EINVAL;
  182. newattrs.ia_size = length;
  183. newattrs.ia_valid = ATTR_SIZE | time_attrs;
  184. if (filp) {
  185. newattrs.ia_file = filp;
  186. newattrs.ia_valid |= ATTR_FILE;
  187. }
  188. mutex_lock(&dentry->d_inode->i_mutex);
  189. err = notify_change(dentry, &newattrs);
  190. mutex_unlock(&dentry->d_inode->i_mutex);
  191. return err;
  192. }
  193. static long do_sys_truncate(const char __user * path, loff_t length)
  194. {
  195. struct nameidata nd;
  196. struct inode * inode;
  197. int error;
  198. error = -EINVAL;
  199. if (length < 0) /* sorry, but loff_t says... */
  200. goto out;
  201. error = user_path_walk(path, &nd);
  202. if (error)
  203. goto out;
  204. inode = nd.dentry->d_inode;
  205. /* For directories it's -EISDIR, for other non-regulars - -EINVAL */
  206. error = -EISDIR;
  207. if (S_ISDIR(inode->i_mode))
  208. goto dput_and_out;
  209. error = -EINVAL;
  210. if (!S_ISREG(inode->i_mode))
  211. goto dput_and_out;
  212. error = vfs_permission(&nd, MAY_WRITE);
  213. if (error)
  214. goto dput_and_out;
  215. error = -EROFS;
  216. if (IS_RDONLY(inode))
  217. goto dput_and_out;
  218. error = -EPERM;
  219. if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
  220. goto dput_and_out;
  221. /*
  222. * Make sure that there are no leases.
  223. */
  224. error = break_lease(inode, FMODE_WRITE);
  225. if (error)
  226. goto dput_and_out;
  227. error = get_write_access(inode);
  228. if (error)
  229. goto dput_and_out;
  230. error = locks_verify_truncate(inode, NULL, length);
  231. if (!error) {
  232. DQUOT_INIT(inode);
  233. error = do_truncate(nd.dentry, length, 0, NULL);
  234. }
  235. put_write_access(inode);
  236. dput_and_out:
  237. path_release(&nd);
  238. out:
  239. return error;
  240. }
  241. asmlinkage long sys_truncate(const char __user * path, unsigned long length)
  242. {
  243. /* on 32-bit boxen it will cut the range 2^31--2^32-1 off */
  244. return do_sys_truncate(path, (long)length);
  245. }
  246. static long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
  247. {
  248. struct inode * inode;
  249. struct dentry *dentry;
  250. struct file * file;
  251. int error;
  252. error = -EINVAL;
  253. if (length < 0)
  254. goto out;
  255. error = -EBADF;
  256. file = fget(fd);
  257. if (!file)
  258. goto out;
  259. /* explicitly opened as large or we are on 64-bit box */
  260. if (file->f_flags & O_LARGEFILE)
  261. small = 0;
  262. dentry = file->f_path.dentry;
  263. inode = dentry->d_inode;
  264. error = -EINVAL;
  265. if (!S_ISREG(inode->i_mode) || !(file->f_mode & FMODE_WRITE))
  266. goto out_putf;
  267. error = -EINVAL;
  268. /* Cannot ftruncate over 2^31 bytes without large file support */
  269. if (small && length > MAX_NON_LFS)
  270. goto out_putf;
  271. error = -EPERM;
  272. if (IS_APPEND(inode))
  273. goto out_putf;
  274. error = locks_verify_truncate(inode, file, length);
  275. if (!error)
  276. error = do_truncate(dentry, length, ATTR_MTIME|ATTR_CTIME, file);
  277. out_putf:
  278. fput(file);
  279. out:
  280. return error;
  281. }
  282. asmlinkage long sys_ftruncate(unsigned int fd, unsigned long length)
  283. {
  284. long ret = do_sys_ftruncate(fd, length, 1);
  285. /* avoid REGPARM breakage on x86: */
  286. prevent_tail_call(ret);
  287. return ret;
  288. }
  289. /* LFS versions of truncate are only needed on 32 bit machines */
  290. #if BITS_PER_LONG == 32
  291. asmlinkage long sys_truncate64(const char __user * path, loff_t length)
  292. {
  293. return do_sys_truncate(path, length);
  294. }
  295. asmlinkage long sys_ftruncate64(unsigned int fd, loff_t length)
  296. {
  297. long ret = do_sys_ftruncate(fd, length, 0);
  298. /* avoid REGPARM breakage on x86: */
  299. prevent_tail_call(ret);
  300. return ret;
  301. }
  302. #endif
  303. /*
  304. * access() needs to use the real uid/gid, not the effective uid/gid.
  305. * We do this by temporarily clearing all FS-related capabilities and
  306. * switching the fsuid/fsgid around to the real ones.
  307. */
  308. asmlinkage long sys_faccessat(int dfd, const char __user *filename, int mode)
  309. {
  310. struct nameidata nd;
  311. int old_fsuid, old_fsgid;
  312. kernel_cap_t old_cap;
  313. int res;
  314. if (mode & ~S_IRWXO) /* where's F_OK, X_OK, W_OK, R_OK? */
  315. return -EINVAL;
  316. old_fsuid = current->fsuid;
  317. old_fsgid = current->fsgid;
  318. old_cap = current->cap_effective;
  319. current->fsuid = current->uid;
  320. current->fsgid = current->gid;
  321. /*
  322. * Clear the capabilities if we switch to a non-root user
  323. *
  324. * FIXME: There is a race here against sys_capset. The
  325. * capabilities can change yet we will restore the old
  326. * value below. We should hold task_capabilities_lock,
  327. * but we cannot because user_path_walk can sleep.
  328. */
  329. if (current->uid)
  330. cap_clear(current->cap_effective);
  331. else
  332. current->cap_effective = current->cap_permitted;
  333. res = __user_walk_fd(dfd, filename, LOOKUP_FOLLOW|LOOKUP_ACCESS, &nd);
  334. if (res)
  335. goto out;
  336. res = vfs_permission(&nd, mode);
  337. /* SuS v2 requires we report a read only fs too */
  338. if(res || !(mode & S_IWOTH) ||
  339. special_file(nd.dentry->d_inode->i_mode))
  340. goto out_path_release;
  341. if(IS_RDONLY(nd.dentry->d_inode))
  342. res = -EROFS;
  343. out_path_release:
  344. path_release(&nd);
  345. out:
  346. current->fsuid = old_fsuid;
  347. current->fsgid = old_fsgid;
  348. current->cap_effective = old_cap;
  349. return res;
  350. }
  351. asmlinkage long sys_access(const char __user *filename, int mode)
  352. {
  353. return sys_faccessat(AT_FDCWD, filename, mode);
  354. }
  355. asmlinkage long sys_chdir(const char __user * filename)
  356. {
  357. struct nameidata nd;
  358. int error;
  359. error = __user_walk(filename,
  360. LOOKUP_FOLLOW|LOOKUP_DIRECTORY|LOOKUP_CHDIR, &nd);
  361. if (error)
  362. goto out;
  363. error = vfs_permission(&nd, MAY_EXEC);
  364. if (error)
  365. goto dput_and_out;
  366. set_fs_pwd(current->fs, nd.mnt, nd.dentry);
  367. dput_and_out:
  368. path_release(&nd);
  369. out:
  370. return error;
  371. }
  372. asmlinkage long sys_fchdir(unsigned int fd)
  373. {
  374. struct file *file;
  375. struct dentry *dentry;
  376. struct inode *inode;
  377. struct vfsmount *mnt;
  378. int error;
  379. error = -EBADF;
  380. file = fget(fd);
  381. if (!file)
  382. goto out;
  383. dentry = file->f_path.dentry;
  384. mnt = file->f_path.mnt;
  385. inode = dentry->d_inode;
  386. error = -ENOTDIR;
  387. if (!S_ISDIR(inode->i_mode))
  388. goto out_putf;
  389. error = file_permission(file, MAY_EXEC);
  390. if (!error)
  391. set_fs_pwd(current->fs, mnt, dentry);
  392. out_putf:
  393. fput(file);
  394. out:
  395. return error;
  396. }
  397. asmlinkage long sys_chroot(const char __user * filename)
  398. {
  399. struct nameidata nd;
  400. int error;
  401. error = __user_walk(filename, LOOKUP_FOLLOW | LOOKUP_DIRECTORY | LOOKUP_NOALT, &nd);
  402. if (error)
  403. goto out;
  404. error = vfs_permission(&nd, MAY_EXEC);
  405. if (error)
  406. goto dput_and_out;
  407. error = -EPERM;
  408. if (!capable(CAP_SYS_CHROOT))
  409. goto dput_and_out;
  410. set_fs_root(current->fs, nd.mnt, nd.dentry);
  411. set_fs_altroot();
  412. error = 0;
  413. dput_and_out:
  414. path_release(&nd);
  415. out:
  416. return error;
  417. }
  418. asmlinkage long sys_fchmod(unsigned int fd, mode_t mode)
  419. {
  420. struct inode * inode;
  421. struct dentry * dentry;
  422. struct file * file;
  423. int err = -EBADF;
  424. struct iattr newattrs;
  425. file = fget(fd);
  426. if (!file)
  427. goto out;
  428. dentry = file->f_path.dentry;
  429. inode = dentry->d_inode;
  430. audit_inode(NULL, inode);
  431. err = -EROFS;
  432. if (IS_RDONLY(inode))
  433. goto out_putf;
  434. err = -EPERM;
  435. if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
  436. goto out_putf;
  437. mutex_lock(&inode->i_mutex);
  438. if (mode == (mode_t) -1)
  439. mode = inode->i_mode;
  440. newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
  441. newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
  442. err = notify_change(dentry, &newattrs);
  443. mutex_unlock(&inode->i_mutex);
  444. out_putf:
  445. fput(file);
  446. out:
  447. return err;
  448. }
  449. asmlinkage long sys_fchmodat(int dfd, const char __user *filename,
  450. mode_t mode)
  451. {
  452. struct nameidata nd;
  453. struct inode * inode;
  454. int error;
  455. struct iattr newattrs;
  456. error = __user_walk_fd(dfd, filename, LOOKUP_FOLLOW, &nd);
  457. if (error)
  458. goto out;
  459. inode = nd.dentry->d_inode;
  460. error = -EROFS;
  461. if (IS_RDONLY(inode))
  462. goto dput_and_out;
  463. error = -EPERM;
  464. if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
  465. goto dput_and_out;
  466. mutex_lock(&inode->i_mutex);
  467. if (mode == (mode_t) -1)
  468. mode = inode->i_mode;
  469. newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
  470. newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
  471. error = notify_change(nd.dentry, &newattrs);
  472. mutex_unlock(&inode->i_mutex);
  473. dput_and_out:
  474. path_release(&nd);
  475. out:
  476. return error;
  477. }
  478. asmlinkage long sys_chmod(const char __user *filename, mode_t mode)
  479. {
  480. return sys_fchmodat(AT_FDCWD, filename, mode);
  481. }
  482. static int chown_common(struct dentry * dentry, uid_t user, gid_t group)
  483. {
  484. struct inode * inode;
  485. int error;
  486. struct iattr newattrs;
  487. error = -ENOENT;
  488. if (!(inode = dentry->d_inode)) {
  489. printk(KERN_ERR "chown_common: NULL inode\n");
  490. goto out;
  491. }
  492. error = -EROFS;
  493. if (IS_RDONLY(inode))
  494. goto out;
  495. error = -EPERM;
  496. if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
  497. goto out;
  498. newattrs.ia_valid = ATTR_CTIME;
  499. if (user != (uid_t) -1) {
  500. newattrs.ia_valid |= ATTR_UID;
  501. newattrs.ia_uid = user;
  502. }
  503. if (group != (gid_t) -1) {
  504. newattrs.ia_valid |= ATTR_GID;
  505. newattrs.ia_gid = group;
  506. }
  507. if (!S_ISDIR(inode->i_mode))
  508. newattrs.ia_valid |= ATTR_KILL_SUID|ATTR_KILL_SGID;
  509. mutex_lock(&inode->i_mutex);
  510. error = notify_change(dentry, &newattrs);
  511. mutex_unlock(&inode->i_mutex);
  512. out:
  513. return error;
  514. }
  515. asmlinkage long sys_chown(const char __user * filename, uid_t user, gid_t group)
  516. {
  517. struct nameidata nd;
  518. int error;
  519. error = user_path_walk(filename, &nd);
  520. if (error)
  521. goto out;
  522. error = chown_common(nd.dentry, user, group);
  523. path_release(&nd);
  524. out:
  525. return error;
  526. }
  527. asmlinkage long sys_fchownat(int dfd, const char __user *filename, uid_t user,
  528. gid_t group, int flag)
  529. {
  530. struct nameidata nd;
  531. int error = -EINVAL;
  532. int follow;
  533. if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
  534. goto out;
  535. follow = (flag & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
  536. error = __user_walk_fd(dfd, filename, follow, &nd);
  537. if (error)
  538. goto out;
  539. error = chown_common(nd.dentry, user, group);
  540. path_release(&nd);
  541. out:
  542. return error;
  543. }
  544. asmlinkage long sys_lchown(const char __user * filename, uid_t user, gid_t group)
  545. {
  546. struct nameidata nd;
  547. int error;
  548. error = user_path_walk_link(filename, &nd);
  549. if (error)
  550. goto out;
  551. error = chown_common(nd.dentry, user, group);
  552. path_release(&nd);
  553. out:
  554. return error;
  555. }
  556. asmlinkage long sys_fchown(unsigned int fd, uid_t user, gid_t group)
  557. {
  558. struct file * file;
  559. int error = -EBADF;
  560. struct dentry * dentry;
  561. file = fget(fd);
  562. if (!file)
  563. goto out;
  564. dentry = file->f_path.dentry;
  565. audit_inode(NULL, dentry->d_inode);
  566. error = chown_common(dentry, user, group);
  567. fput(file);
  568. out:
  569. return error;
  570. }
  571. static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt,
  572. int flags, struct file *f,
  573. int (*open)(struct inode *, struct file *))
  574. {
  575. struct inode *inode;
  576. int error;
  577. f->f_flags = flags;
  578. f->f_mode = ((flags+1) & O_ACCMODE) | FMODE_LSEEK |
  579. FMODE_PREAD | FMODE_PWRITE;
  580. inode = dentry->d_inode;
  581. if (f->f_mode & FMODE_WRITE) {
  582. error = get_write_access(inode);
  583. if (error)
  584. goto cleanup_file;
  585. }
  586. f->f_mapping = inode->i_mapping;
  587. f->f_path.dentry = dentry;
  588. f->f_path.mnt = mnt;
  589. f->f_pos = 0;
  590. f->f_op = fops_get(inode->i_fop);
  591. file_move(f, &inode->i_sb->s_files);
  592. if (!open && f->f_op)
  593. open = f->f_op->open;
  594. if (open) {
  595. error = open(inode, f);
  596. if (error)
  597. goto cleanup_all;
  598. }
  599. f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
  600. file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);
  601. /* NB: we're sure to have correct a_ops only after f_op->open */
  602. if (f->f_flags & O_DIRECT) {
  603. if (!f->f_mapping->a_ops ||
  604. ((!f->f_mapping->a_ops->direct_IO) &&
  605. (!f->f_mapping->a_ops->get_xip_page))) {
  606. fput(f);
  607. f = ERR_PTR(-EINVAL);
  608. }
  609. }
  610. return f;
  611. cleanup_all:
  612. fops_put(f->f_op);
  613. if (f->f_mode & FMODE_WRITE)
  614. put_write_access(inode);
  615. file_kill(f);
  616. f->f_path.dentry = NULL;
  617. f->f_path.mnt = NULL;
  618. cleanup_file:
  619. put_filp(f);
  620. dput(dentry);
  621. mntput(mnt);
  622. return ERR_PTR(error);
  623. }
  624. /*
  625. * Note that while the flag value (low two bits) for sys_open means:
  626. * 00 - read-only
  627. * 01 - write-only
  628. * 10 - read-write
  629. * 11 - special
  630. * it is changed into
  631. * 00 - no permissions needed
  632. * 01 - read-permission
  633. * 10 - write-permission
  634. * 11 - read-write
  635. * for the internal routines (ie open_namei()/follow_link() etc). 00 is
  636. * used by symlinks.
  637. */
  638. static struct file *do_filp_open(int dfd, const char *filename, int flags,
  639. int mode)
  640. {
  641. int namei_flags, error;
  642. struct nameidata nd;
  643. namei_flags = flags;
  644. if ((namei_flags+1) & O_ACCMODE)
  645. namei_flags++;
  646. error = open_namei(dfd, filename, namei_flags, mode, &nd);
  647. if (!error)
  648. return nameidata_to_filp(&nd, flags);
  649. return ERR_PTR(error);
  650. }
  651. struct file *filp_open(const char *filename, int flags, int mode)
  652. {
  653. return do_filp_open(AT_FDCWD, filename, flags, mode);
  654. }
  655. EXPORT_SYMBOL(filp_open);
  656. /**
  657. * lookup_instantiate_filp - instantiates the open intent filp
  658. * @nd: pointer to nameidata
  659. * @dentry: pointer to dentry
  660. * @open: open callback
  661. *
  662. * Helper for filesystems that want to use lookup open intents and pass back
  663. * a fully instantiated struct file to the caller.
  664. * This function is meant to be called from within a filesystem's
  665. * lookup method.
  666. * Beware of calling it for non-regular files! Those ->open methods might block
  667. * (e.g. in fifo_open), leaving you with parent locked (and in case of fifo,
  668. * leading to a deadlock, as nobody can open that fifo anymore, because
  669. * another process to open fifo will block on locked parent when doing lookup).
  670. * Note that in case of error, nd->intent.open.file is destroyed, but the
  671. * path information remains valid.
  672. * If the open callback is set to NULL, then the standard f_op->open()
  673. * filesystem callback is substituted.
  674. */
  675. struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry,
  676. int (*open)(struct inode *, struct file *))
  677. {
  678. if (IS_ERR(nd->intent.open.file))
  679. goto out;
  680. if (IS_ERR(dentry))
  681. goto out_err;
  682. nd->intent.open.file = __dentry_open(dget(dentry), mntget(nd->mnt),
  683. nd->intent.open.flags - 1,
  684. nd->intent.open.file,
  685. open);
  686. out:
  687. return nd->intent.open.file;
  688. out_err:
  689. release_open_intent(nd);
  690. nd->intent.open.file = (struct file *)dentry;
  691. goto out;
  692. }
  693. EXPORT_SYMBOL_GPL(lookup_instantiate_filp);
  694. /**
  695. * nameidata_to_filp - convert a nameidata to an open filp.
  696. * @nd: pointer to nameidata
  697. * @flags: open flags
  698. *
  699. * Note that this function destroys the original nameidata
  700. */
  701. struct file *nameidata_to_filp(struct nameidata *nd, int flags)
  702. {
  703. struct file *filp;
  704. /* Pick up the filp from the open intent */
  705. filp = nd->intent.open.file;
  706. /* Has the filesystem initialised the file for us? */
  707. if (filp->f_path.dentry == NULL)
  708. filp = __dentry_open(nd->dentry, nd->mnt, flags, filp, NULL);
  709. else
  710. path_release(nd);
  711. return filp;
  712. }
  713. /*
  714. * dentry_open() will have done dput(dentry) and mntput(mnt) if it returns an
  715. * error.
  716. */
  717. struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags)
  718. {
  719. int error;
  720. struct file *f;
  721. error = -ENFILE;
  722. f = get_empty_filp();
  723. if (f == NULL) {
  724. dput(dentry);
  725. mntput(mnt);
  726. return ERR_PTR(error);
  727. }
  728. return __dentry_open(dentry, mnt, flags, f, NULL);
  729. }
  730. EXPORT_SYMBOL(dentry_open);
  731. /*
  732. * Find an empty file descriptor entry, and mark it busy.
  733. */
  734. int get_unused_fd(void)
  735. {
  736. struct files_struct * files = current->files;
  737. int fd, error;
  738. struct fdtable *fdt;
  739. error = -EMFILE;
  740. spin_lock(&files->file_lock);
  741. repeat:
  742. fdt = files_fdtable(files);
  743. fd = find_next_zero_bit(fdt->open_fds->fds_bits, fdt->max_fds,
  744. files->next_fd);
  745. /*
  746. * N.B. For clone tasks sharing a files structure, this test
  747. * will limit the total number of files that can be opened.
  748. */
  749. if (fd >= current->signal->rlim[RLIMIT_NOFILE].rlim_cur)
  750. goto out;
  751. /* Do we need to expand the fd array or fd set? */
  752. error = expand_files(files, fd);
  753. if (error < 0)
  754. goto out;
  755. if (error) {
  756. /*
  757. * If we needed to expand the fs array we
  758. * might have blocked - try again.
  759. */
  760. error = -EMFILE;
  761. goto repeat;
  762. }
  763. FD_SET(fd, fdt->open_fds);
  764. FD_CLR(fd, fdt->close_on_exec);
  765. files->next_fd = fd + 1;
  766. #if 1
  767. /* Sanity check */
  768. if (fdt->fd[fd] != NULL) {
  769. printk(KERN_WARNING "get_unused_fd: slot %d not NULL!\n", fd);
  770. fdt->fd[fd] = NULL;
  771. }
  772. #endif
  773. error = fd;
  774. out:
  775. spin_unlock(&files->file_lock);
  776. return error;
  777. }
  778. EXPORT_SYMBOL(get_unused_fd);
  779. static void __put_unused_fd(struct files_struct *files, unsigned int fd)
  780. {
  781. struct fdtable *fdt = files_fdtable(files);
  782. __FD_CLR(fd, fdt->open_fds);
  783. if (fd < files->next_fd)
  784. files->next_fd = fd;
  785. }
  786. void fastcall put_unused_fd(unsigned int fd)
  787. {
  788. struct files_struct *files = current->files;
  789. spin_lock(&files->file_lock);
  790. __put_unused_fd(files, fd);
  791. spin_unlock(&files->file_lock);
  792. }
  793. EXPORT_SYMBOL(put_unused_fd);
  794. /*
  795. * Install a file pointer in the fd array.
  796. *
  797. * The VFS is full of places where we drop the files lock between
  798. * setting the open_fds bitmap and installing the file in the file
  799. * array. At any such point, we are vulnerable to a dup2() race
  800. * installing a file in the array before us. We need to detect this and
  801. * fput() the struct file we are about to overwrite in this case.
  802. *
  803. * It should never happen - if we allow dup2() do it, _really_ bad things
  804. * will follow.
  805. */
  806. void fastcall fd_install(unsigned int fd, struct file * file)
  807. {
  808. struct files_struct *files = current->files;
  809. struct fdtable *fdt;
  810. spin_lock(&files->file_lock);
  811. fdt = files_fdtable(files);
  812. BUG_ON(fdt->fd[fd] != NULL);
  813. rcu_assign_pointer(fdt->fd[fd], file);
  814. spin_unlock(&files->file_lock);
  815. }
  816. EXPORT_SYMBOL(fd_install);
  817. long do_sys_open(int dfd, const char __user *filename, int flags, int mode)
  818. {
  819. char *tmp = getname(filename);
  820. int fd = PTR_ERR(tmp);
  821. if (!IS_ERR(tmp)) {
  822. fd = get_unused_fd();
  823. if (fd >= 0) {
  824. struct file *f = do_filp_open(dfd, tmp, flags, mode);
  825. if (IS_ERR(f)) {
  826. put_unused_fd(fd);
  827. fd = PTR_ERR(f);
  828. } else {
  829. fsnotify_open(f->f_path.dentry);
  830. fd_install(fd, f);
  831. }
  832. }
  833. putname(tmp);
  834. }
  835. return fd;
  836. }
  837. asmlinkage long sys_open(const char __user *filename, int flags, int mode)
  838. {
  839. long ret;
  840. if (force_o_largefile())
  841. flags |= O_LARGEFILE;
  842. ret = do_sys_open(AT_FDCWD, filename, flags, mode);
  843. /* avoid REGPARM breakage on x86: */
  844. prevent_tail_call(ret);
  845. return ret;
  846. }
  847. EXPORT_SYMBOL_GPL(sys_open);
  848. asmlinkage long sys_openat(int dfd, const char __user *filename, int flags,
  849. int mode)
  850. {
  851. long ret;
  852. if (force_o_largefile())
  853. flags |= O_LARGEFILE;
  854. ret = do_sys_open(dfd, filename, flags, mode);
  855. /* avoid REGPARM breakage on x86: */
  856. prevent_tail_call(ret);
  857. return ret;
  858. }
  859. #ifndef __alpha__
  860. /*
  861. * For backward compatibility? Maybe this should be moved
  862. * into arch/i386 instead?
  863. */
  864. asmlinkage long sys_creat(const char __user * pathname, int mode)
  865. {
  866. return sys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
  867. }
  868. #endif
  869. /*
  870. * "id" is the POSIX thread ID. We use the
  871. * files pointer for this..
  872. */
  873. int filp_close(struct file *filp, fl_owner_t id)
  874. {
  875. int retval = 0;
  876. if (!file_count(filp)) {
  877. printk(KERN_ERR "VFS: Close: file count is 0\n");
  878. return 0;
  879. }
  880. if (filp->f_op && filp->f_op->flush)
  881. retval = filp->f_op->flush(filp, id);
  882. dnotify_flush(filp, id);
  883. locks_remove_posix(filp, id);
  884. fput(filp);
  885. return retval;
  886. }
  887. EXPORT_SYMBOL(filp_close);
  888. /*
  889. * Careful here! We test whether the file pointer is NULL before
  890. * releasing the fd. This ensures that one clone task can't release
  891. * an fd while another clone is opening it.
  892. */
  893. asmlinkage long sys_close(unsigned int fd)
  894. {
  895. struct file * filp;
  896. struct files_struct *files = current->files;
  897. struct fdtable *fdt;
  898. int retval;
  899. spin_lock(&files->file_lock);
  900. fdt = files_fdtable(files);
  901. if (fd >= fdt->max_fds)
  902. goto out_unlock;
  903. filp = fdt->fd[fd];
  904. if (!filp)
  905. goto out_unlock;
  906. rcu_assign_pointer(fdt->fd[fd], NULL);
  907. FD_CLR(fd, fdt->close_on_exec);
  908. __put_unused_fd(files, fd);
  909. spin_unlock(&files->file_lock);
  910. retval = filp_close(filp, files);
  911. /* can't restart close syscall because file table entry was cleared */
  912. if (unlikely(retval == -ERESTARTSYS ||
  913. retval == -ERESTARTNOINTR ||
  914. retval == -ERESTARTNOHAND ||
  915. retval == -ERESTART_RESTARTBLOCK))
  916. retval = -EINTR;
  917. return retval;
  918. out_unlock:
  919. spin_unlock(&files->file_lock);
  920. return -EBADF;
  921. }
  922. EXPORT_SYMBOL(sys_close);
  923. /*
  924. * This routine simulates a hangup on the tty, to arrange that users
  925. * are given clean terminals at login time.
  926. */
  927. asmlinkage long sys_vhangup(void)
  928. {
  929. if (capable(CAP_SYS_TTY_CONFIG)) {
  930. /* XXX: this needs locking */
  931. tty_vhangup(current->signal->tty);
  932. return 0;
  933. }
  934. return -EPERM;
  935. }
  936. /*
  937. * Called when an inode is about to be open.
  938. * We use this to disallow opening large files on 32bit systems if
  939. * the caller didn't specify O_LARGEFILE. On 64bit systems we force
  940. * on this flag in sys_open.
  941. */
  942. int generic_file_open(struct inode * inode, struct file * filp)
  943. {
  944. if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
  945. return -EFBIG;
  946. return 0;
  947. }
  948. EXPORT_SYMBOL(generic_file_open);
  949. /*
  950. * This is used by subsystems that don't want seekable
  951. * file descriptors
  952. */
  953. int nonseekable_open(struct inode *inode, struct file *filp)
  954. {
  955. filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
  956. return 0;
  957. }
  958. EXPORT_SYMBOL(nonseekable_open);